def setUp(self):
"Initial Setup"
if not self.prepared:
Object.objects.all().delete()
# Create objects
self.group, created = Group.objects.get_or_create(name='test')
duser, created = DjangoUser.objects.get_or_create(
username=self.username)
duser.set_password(self.password)
duser.save()
self.user, created = User.objects.get_or_create(user=duser)
self.user.save()
perspective, created = Perspective.objects.get_or_create(
name='default')
perspective.set_default_user()
perspective.save()
ModuleSetting.set('default_perspective', perspective.id)
self.perspective = Perspective(name='test')
self.perspective.set_default_user()
self.perspective.save()
self.group = Group(name='test')
self.group.save()
self.client = Client()
self.prepared = True
def setUp(self):
"Initial Setup"
if not self.prepared:
# Clean up first
Object.objects.all().delete()
# Create objects
try:
self.group = Group.objects.get(name='test')
except Group.DoesNotExist:
Group.objects.all().delete()
self.group = Group(name='test')
self.group.save()
try:
self.user = DjangoUser.objects.get(username=self.username)
self.user.set_password(self.password)
try:
self.profile = self.user.get_profile()
except Exception:
User.objects.all().delete()
self.user = DjangoUser(username=self.username, password='')
self.user.set_password(self.password)
self.user.save()
except DjangoUser.DoesNotExist:
User.objects.all().delete()
self.user = DjangoUser(username=self.username, password='')
self.user.set_password(self.password)
self.user.save()
try:
perspective = Perspective.objects.get(name='default')
except Perspective.DoesNotExist:
Perspective.objects.all().delete()
perspective = Perspective(name='default')
perspective.set_default_user()
perspective.save()
ModuleSetting.set('default_perspective', perspective.id)
self.folder = KnowledgeFolder(name='test', treepath='test')
self.folder.set_default_user()
self.folder.save()
self.category = KnowledgeCategory(name='test', treepath='test')
self.category.set_default_user()
self.category.save()
self.item = KnowledgeItem(name='test', folder=self.folder,
category=self.category, treepath='test')
self.item.set_default_user()
self.item.save()
# parent folder
self.parent = KnowledgeFolder(name='test', treepath='test')
self.parent.set_default_user()
self.parent.save()
self.client = Client()
self.prepared = True
def setUp(self):
"Initial Setup"
if not self.prepared:
Object.objects.all().delete()
# Create objects
try:
self.group = Group.objects.get(name='test')
except Group.DoesNotExist:
Group.objects.all().delete()
self.group = Group(name='test')
self.group.save()
try:
self.user = DjangoUser.objects.get(username=self.username)
self.user.set_password(self.password)
try:
self.profile = self.user.get_profile()
except Exception:
User.objects.all().delete()
self.user = DjangoUser(username=self.username, password='')
self.user.set_password(self.password)
self.user.save()
except DjangoUser.DoesNotExist:
User.objects.all().delete()
self.user = DjangoUser(username=self.username, password='')
self.user.set_password(self.password)
self.user.save()
try:
perspective = Perspective.objects.get(name='default')
except Perspective.DoesNotExist:
Perspective.objects.all().delete()
perspective = Perspective(name='default')
perspective.set_default_user()
perspective.save()
ModuleSetting.set('default_perspective', perspective.id)
self.folder = Folder(name='test')
self.folder.set_default_user()
self.folder.save()
self.document = Document(title='test_document', folder=self.folder)
self.document.set_default_user()
self.document.save()
self.file = File(name='test_file', folder=self.folder)
self.file.set_default_user()
self.file.save()
self.link = WebLink(title='test', folder=self.folder, url='test')
self.link.set_default_user()
self.link.save()
self.client = Client()
self.prepared = True
def test_model_group(self):
"Test Group model"
obj = Group(name='test')
obj.save()
self.assertEquals('test', obj.name)
self.assertNotEquals(obj.id, None)
obj.delete()
def setUp(self):
"Initial Setup"
if not self.prepared:
# Clean up first
Object.objects.all().delete()
# Create objects
try:
self.group = Group.objects.get(name='test')
except Group.DoesNotExist:
Group.objects.all().delete()
self.group = Group(name='test')
self.group.save()
try:
self.user = DjangoUser.objects.get(username=self.username)
self.user.set_password(self.password)
try:
self.profile = self.user.get_profile()
except Exception:
User.objects.all().delete()
self.user = DjangoUser(username=self.username, password='')
self.user.set_password(self.password)
self.user.save()
except DjangoUser.DoesNotExist:
User.objects.all().delete()
self.user = DjangoUser(username=self.username, password='')
self.user.set_password(self.password)
self.user.save()
try:
perspective = Perspective.objects.get(name='default')
except Perspective.DoesNotExist:
Perspective.objects.all().delete()
perspective = Perspective(name='default')
perspective.save()
ModuleSetting.set('default_perspective', perspective.id)
self.contact_type = ContactType(name='Person')
self.contact_type.set_default_user()
self.contact_type.save()
self.contact = Contact(name='Test', contact_type=self.contact_type)
self.contact.set_default_user()
self.contact.save()
self.field = ContactField(name='Test',
label='test',
field_type='text')
self.field.set_default_user()
self.field.save()
self.client = Client()
self.prepared = True
def setUp(self):
"Initial Setup"
if not self.prepared:
Object.objects.all().delete()
# Create objects
try:
self.group = Group.objects.get(name='test')
except Group.DoesNotExist:
Group.objects.all().delete()
self.group = Group(name='test')
self.group.save()
try:
self.user = DjangoUser.objects.get(username=self.username)
self.user.set_password(self.password)
try:
self.profile = self.user.get_profile()
except Exception:
User.objects.all().delete()
self.user = DjangoUser(username=self.username, password='')
self.user.set_password(self.password)
self.user.save()
except DjangoUser.DoesNotExist:
User.objects.all().delete()
self.user = DjangoUser(username=self.username, password='')
self.user.set_password(self.password)
self.user.save()
try:
perspective = Perspective.objects.get(name='default')
except Perspective.DoesNotExist:
Perspective.objects.all().delete()
perspective = Perspective(name='default')
perspective.set_default_user()
perspective.save()
ModuleSetting.set('default_perspective', perspective.id)
self.report = Report(name='test')
self.report.set_default_user()
self.report.save()
self.chart = Chart(name='test_chart', report=self.report)
self.chart.set_default_user()
self.chart.save()
self.client = Client()
self.prepared = True
def setUp(self):
"Initial Setup"
if not self.prepared:
Object.objects.all().delete()
# Create objects
try:
self.group = Group.objects.get(name='test')
except Group.DoesNotExist:
Group.objects.all().delete()
self.group = Group(name='test')
self.group.save()
try:
self.user = DjangoUser.objects.get(username=self.username)
self.user.set_password(self.password)
try:
self.profile = self.user.get_profile()
except Exception:
User.objects.all().delete()
self.user = DjangoUser(username=self.username, password='')
self.user.set_password(self.password)
self.user.save()
except DjangoUser.DoesNotExist:
User.objects.all().delete()
self.user = DjangoUser(username=self.username, password='')
self.user.set_password(self.password)
self.user.save()
try:
perspective = Perspective.objects.get(name='default')
except Perspective.DoesNotExist:
Perspective.objects.all().delete()
perspective = Perspective(name='default')
perspective.set_default_user()
perspective.save()
ModuleSetting.set('default_perspective', perspective.id)
self.perspective = Perspective(name='test')
self.perspective.set_default_user()
self.perspective.save()
self.group = Group(name='test')
self.group.save()
self.client = Client()
self.prepared = True
def setUp(self):
"Initial Setup"
if not self.prepared:
# Clean up first
Object.objects.all().delete()
# Create objects
try:
self.group = Group.objects.get(name='test')
except Group.DoesNotExist:
Group.objects.all().delete()
self.group = Group(name='test')
self.group.save()
try:
self.user = DjangoUser.objects.get(username=self.username)
self.user.set_password(self.password)
try:
self.profile = self.user.get_profile()
except Exception:
User.objects.all().delete()
self.user = DjangoUser(username=self.username, password='')
self.user.set_password(self.password)
self.user.save()
except DjangoUser.DoesNotExist:
User.objects.all().delete()
self.user = DjangoUser(username=self.username, password='')
self.user.set_password(self.password)
self.user.save()
try:
perspective = Perspective.objects.get(name='default')
except Perspective.DoesNotExist:
Perspective.objects.all().delete()
perspective = Perspective(name='default')
perspective.set_default_user()
perspective.save()
ModuleSetting.set('default_perspective', perspective.id)
self.event = Event(name='TestStatus', end=datetime.now())
self.event.set_default_user()
self.event.save()
self.client = Client()
self.prepared = True
def setUp(self):
"Initial Setup"
if not self.prepared:
# Clean up first
Object.objects.all().delete()
# Create objects
try:
self.group = Group.objects.get(name='test')
except Group.DoesNotExist:
Group.objects.all().delete()
self.group = Group(name='test')
self.group.save()
try:
self.user = DjangoUser.objects.get(username=self.username)
self.user.set_password(self.password)
try:
self.profile = self.user.get_profile()
except Exception:
User.objects.all().delete()
self.user = DjangoUser(username=self.username, password='')
self.user.set_password(self.password)
self.user.save()
except DjangoUser.DoesNotExist:
User.objects.all().delete()
self.user = DjangoUser(username=self.username, password='')
self.user.set_password(self.password)
self.user.save()
try:
perspective = Perspective.objects.get(name='default')
except Perspective.DoesNotExist:
Perspective.objects.all().delete()
perspective = Perspective(name='default')
perspective.set_default_user()
perspective.save()
ModuleSetting.set('default_perspective', perspective.id)
self.contact_type = ContactType(name='test')
self.contact_type.set_default_user()
self.contact_type.save()
self.contact = Contact(name='test', contact_type=self.contact_type)
self.contact.set_default_user()
self.contact.save()
self.stream = MessageStream(name='test')
self.stream.set_default_user()
self.stream.save()
self.message = Message(title='test', body='test', author=self.contact, stream=self.stream)
self.message.set_default_user()
self.message.save()
self.client = Client()
self.prepared = True
def setUp(self):
"Initial Setup"
if not self.prepared:
Object.objects.all().delete()
# Create objects
self.group, created = Group.objects.get_or_create(name='test')
duser, created = DjangoUser.objects.get_or_create(username=self.username)
duser.set_password(self.password)
duser.save()
self.user, created = User.objects.get_or_create(user=duser)
self.user.save()
perspective, created = Perspective.objects.get_or_create(name='default')
perspective.set_default_user()
perspective.save()
ModuleSetting.set('default_perspective', perspective.id)
self.perspective = Perspective(name='test')
self.perspective.set_default_user()
self.perspective.save()
self.group = Group(name='test')
self.group.save()
self.client = Client()
self.prepared = True
def test_model_user(self):
"Test User model"
username = "******"
password = "******"
user = DjangoUser(username=username, password=password)
user.set_password(password)
user.save()
self.assertEquals('test', user.username)
self.assertNotEquals(user.id, None)
group = Group(name='test')
group.save()
self.assertEquals('test', group.name)
self.assertNotEquals(group.id, None)
profile = User(user=user, default_group=group)
profile.save()
self.assertEquals(user, profile.user)
self.assertNotEquals(profile.id, None)
profile.delete()
group.delete()
def test_model_group(self):
"Test Group model"
obj = Group(name='test')
obj.save()
self.assertEquals('test', obj.name)
self.assertNotEquals(obj.id, None)
obj.delete()
def test_model_user(self):
"Test User model"
username = "******"
password = "******"
user = DjangoUser(username=username, password=password)
user.set_password(password)
user.save()
self.assertEquals('test', user.username)
self.assertNotEquals(user.id, None)
group = Group(name='test')
group.save()
self.assertEquals('test', group.name)
self.assertNotEquals(group.id, None)
profile = User(user=user, default_group=group)
profile.save()
self.assertEquals(user, profile.user)
self.assertNotEquals(profile.id, None)
profile.delete()
group.delete()
class ProjectsAPITest(TestCase):
"Projects functional tests for api"
username = "******"
password = "******"
prepared = False
authentication_headers ={"CONTENT_TYPE": "application/json",
"HTTP_AUTHORIZATION" : "Basic YXBpX3Rlc3Q6YXBpX3Bhc3N3b3Jk" }
content_type ='application/json'
def setUp(self):
"Initial Setup"
if not self.prepared:
# Clean up first
Object.objects.all().delete()
User.objects.all().delete()
# Create objects
try:
self.group = Group.objects.get(name='api_test')
except Group.DoesNotExist:
Group.objects.all().delete()
self.group = Group(name='api_test')
self.group.save()
try:
self.user = DjangoUser.objects.get(username=self.username)
self.user.set_password(self.password)
try:
self.profile = self.user.get_profile()
except Exception:
User.objects.all().delete()
self.user = DjangoUser(username=self.username, password='')
self.user.set_password(self.password)
self.user.save()
except DjangoUser.DoesNotExist:
User.objects.all().delete()
self.user = DjangoUser(username=self.username, password='')
self.user.set_password(self.password)
self.user.save()
try:
perspective = Perspective.objects.get(name='default')
except Perspective.DoesNotExist:
Perspective.objects.all().delete()
perspective = Perspective(name='default')
perspective.set_default_user()
perspective.save()
ModuleSetting.set('default_perspective', perspective.id)
self.contact_type = ContactType(name='api_test')
self.contact_type.set_default_user()
self.contact_type.save()
self.contact = Contact(name='api_test', contact_type=self.contact_type)
self.contact.set_default_user()
self.contact.save()
self.project = Project(name='api_test', manager=self.contact, client=self.contact)
self.project.set_default_user()
self.project.save()
self.status = TaskStatus(name='api_test')
self.status.set_default_user()
self.status.save()
self.milestone = Milestone(name='api_test', project=self.project, status=self.status)
self.milestone.set_default_user()
self.milestone.save()
self.task = Task(name='api_test', project=self.project, status=self.status, priority=3)
self.task.set_default_user()
self.task.save()
self.time_slot = TaskTimeSlot(task=self.task, details='api_test', time_from=datetime.now(), user=self.user.get_profile())
self.time_slot.set_default_user()
self.time_slot.save()
self.parent = Project(name='api_test')
self.parent.set_default_user()
self.parent.save()
self.parent_task = Task(name='api_test', project=self.project, status=self.status, priority=3)
self.parent_task.set_default_user()
self.parent_task.save()
self.client = Client()
self.prepared = True
def test_unauthenticated_access(self):
"Test index page at /projects"
response = self.client.get('/api/projects/projects')
# Redirects as unauthenticated
self.assertEquals(response.status_code, 401)
# Get info about projects, milestones, status, tasks, tasktimes.
def test_get_project_list(self):
""" Test index page api/projects """
response = self.client.get(path=reverse('api_projects'), **self.authentication_headers)
self.assertEquals(response.status_code, 200)
def test_get_status_list(self):
""" Test index page api/status """
response = self.client.get(path=reverse('api_projects_status'), **self.authentication_headers)
self.assertEquals(response.status_code, 200)
def test_get_milestones_list(self):
""" Test index page api/milestones """
response = self.client.get(path=reverse('api_projects_milestones'), **self.authentication_headers)
self.assertEquals(response.status_code, 200)
def test_get_task_list(self):
""" Test index page api/tasks """
response = self.client.get(path=reverse('api_projects_tasks'), **self.authentication_headers)
self.assertEquals(response.status_code, 200)
def test_get_tasktimes_list(self):
""" Test index page api/tasktimes """
response = self.client.get(path=reverse('api_projects_tasktimes'), **self.authentication_headers)
self.assertEquals(response.status_code, 200)
def test_get_project(self):
response = self.client.get(reverse('api_projects', kwargs={'object_ptr': self.project.id}), **self.authentication_headers)
self.assertEquals(response.status_code, 200)
data = json.loads(response.content)
self.assertEquals(data['id'], self.project.id)
self.assertEquals(data['name'], self.project.name)
self.assertEquals(data['details'], self.project.details)
def test_get_status(self):
response = self.client.get(reverse('api_projects_status', kwargs={'object_ptr': self.status.id}), **self.authentication_headers)
self.assertEquals(response.status_code, 200)
data = json.loads(response.content)
self.assertEquals(data['id'], self.status.id)
self.assertEquals(data['name'], self.status.name)
def test_get_milestone(self):
response = self.client.get(reverse('api_projects_milestones', kwargs={'object_ptr': self.milestone.id}), **self.authentication_headers)
self.assertEquals(response.status_code, 200)
data = json.loads(response.content)
self.assertEquals(data['id'], self.milestone.id)
self.assertEquals(data['name'], self.milestone.name)
self.assertEquals(data['project']['id'], self.milestone.project.id)
self.assertEquals(data['status']['id'], self.milestone.status.id)
def test_get_task(self):
response = self.client.get(reverse('api_projects_tasks', kwargs={'object_ptr': self.task.id}), **self.authentication_headers)
self.assertEquals(response.status_code, 200)
data = json.loads(response.content)
self.assertEquals(data['id'], self.task.id)
self.assertEquals(data['name'], self.task.name)
self.assertEquals(data['priority'], self.task.priority)
self.assertEquals(data['project']['id'], self.task.project.id)
self.assertEquals(data['status']['id'], self.task.status.id)
def test_get_timeslot(self):
response = self.client.get(reverse('api_projects_tasktimes', kwargs={'object_ptr': self.time_slot.id}), **self.authentication_headers)
self.assertEquals(response.status_code, 200)
data = json.loads(response.content)
self.assertEquals(data['id'], self.time_slot.id)
self.assertEquals(data['task']['id'], self.time_slot.task.id)
# Common test
def test_common_project(self):
#create new project
new_project = {'name': 'api test',
'details': '<p>test details</p>'}
response = self.client.post(reverse('api_projects'), data=json.dumps(new_project),
content_type=self.content_type, **self.authentication_headers)
#print response.request
self.assertEquals(response.status_code, 200)
# check data in response
data = json.loads(response.content)
self.assertEquals(data['name'], new_project['name'])
self.assertEquals(data['details'], new_project['details'])
project_id = data['id']
#get info about new project
response = self.client.get(path=reverse('api_projects', kwargs={'object_ptr': project_id}), **self.authentication_headers)
self.assertEquals(response.status_code, 200)
#get statuses list
response = self.client.get(path=reverse('api_projects_status'), **self.authentication_headers)
self.assertEquals(response.status_code, 200)
statuses = json.loads(response.content)
fstatus = statuses[0]['id']
#create new task status
new_status = {'name': 'Open api test',
'active': True,
'hidden': False,
'details': '<p>test details</p>'}
response = self.client.post(reverse('api_projects_status'), data=json.dumps(new_status),
content_type=self.content_type, **self.authentication_headers)
self.assertEquals(response.status_code, 200)
data = json.loads(response.content)
self.assertEquals(data['name'], new_status['name'])
self.assertEquals(data['active'], new_status['active'])
self.assertEquals(data['hidden'], new_status['hidden'])
self.assertEquals(data['details'], new_status['details'])
sstatus = data['id']
#create new milestone
new_milestone = {'name': 'api test milestone',
'status': fstatus,
'project': project_id,
'start_date': '2011-06-09 12:00:00',
'details': '<p>test details</p>'}
response = self.client.post(reverse('api_projects_milestones'), data=json.dumps(new_milestone),
content_type=self.content_type, **self.authentication_headers)
self.assertEquals(response.status_code, 200)
data = json.loads(response.content)
self.assertEquals(data['name'], new_milestone['name'])
self.assertEquals(data['status']['id'], new_milestone['status'])
self.assertEquals(data['project']['id'], new_milestone['project'])
self.assertEquals(data['details'], new_milestone['details'])
milestone_id = data['id']
# create new task
new_task = {'name': 'api test task',
'status': sstatus,
'project': project_id,
'milestone': milestone_id,
'priority': 5,
'start_date': '2011-06-02 12:00:00',
'estimated_time': 5000,
'details': '<p>test details</p>'
}
response = self.client.post(reverse('api_projects_tasks'), data=json.dumps(new_task),
content_type=self.content_type, **self.authentication_headers)
self.assertEquals(response.status_code, 200)
data = json.loads(response.content)
self.assertEquals(data['name'], new_task['name'])
self.assertEquals(data['priority'], new_task['priority'])
self.assertEquals(data['status']['id'], new_task['status'])
self.assertEquals(data['project']['id'], new_task['project'])
self.assertEquals(data['milestone']['id'], new_task['milestone'])
self.assertEquals(data['estimated_time'], new_task['estimated_time'])
self.assertEquals(data['details'], new_task['details'])
task_id = data['id']
#create new subtask
new_sub_task = {'name': 'api test task',
'status': sstatus,
'parent': task_id,
'project': project_id,
'priority': 5,
'start_date': '2011-06-02 13:00:00',
'estimated_time': 2500,
'details': '<p>test details</p>'
}
response = self.client.post(reverse('api_projects_tasks'), data=json.dumps(new_sub_task),
content_type=self.content_type, **self.authentication_headers)
self.assertEquals(response.status_code, 200)
data = json.loads(response.content)
self.assertEquals(data['name'], new_sub_task['name'])
self.assertEquals(data['priority'], new_sub_task['priority'])
self.assertEquals(data['status']['id'], new_sub_task['status'])
self.assertEquals(data['parent']['id'], new_sub_task['parent'])
self.assertEquals(data['project']['id'], new_sub_task['project'])
self.assertEquals(data['estimated_time'], new_sub_task['estimated_time'])
self.assertEquals(data['details'], new_sub_task['details'])
sub_task_id = data['id']
#create task time
new_tasktime = {'task': task_id,
'minutes': 400,
'details': '<p>test details</p>'
}
response = self.client.post(reverse('api_projects_tasktimes'), data=json.dumps(new_tasktime),
content_type=self.content_type, **self.authentication_headers)
self.assertEquals(response.status_code, 200)
data = json.loads(response.content)
self.assertEquals(data['task']['id'], new_tasktime['task'])
self.assertEquals(data['details'], new_tasktime['details'])
tasktime_id = data['id']
#start task time
response = self.client.get(path=reverse('api_projects_tasktime_start', kwargs={'task_id': sub_task_id}), **self.authentication_headers)
self.assertEquals(response.status_code, 200)
data = json.loads(response.content)
slot_id = data['id']
sleep(60)
#stop task time
response = self.client.post(reverse('api_projects_tasktime_stop', kwargs={'slot_id': slot_id}), data=json.dumps({'details':'<p>test details</p>'}),
content_type=self.content_type, **self.authentication_headers)
self.assertEquals(response.status_code, 200)
#delete task time
response = self.client.delete(reverse('api_projects_tasktimes', kwargs={'object_ptr': tasktime_id}), **self.authentication_headers)
self.assertEquals(response.status_code, 204)
#delete task
response = self.client.delete(reverse('api_projects_tasks', kwargs={'object_ptr': task_id}), **self.authentication_headers)
self.assertEquals(response.status_code, 204)
# check subtask
response = self.client.get(path=reverse('api_projects_tasks', kwargs={'object_ptr': sub_task_id}), **self.authentication_headers)
self.assertEquals(response.status_code, 404)
#delete milestone
response = self.client.delete(reverse('api_projects_milestones', kwargs={'object_ptr': milestone_id}), **self.authentication_headers)
self.assertEquals(response.status_code, 204)
#delete status
response = self.client.delete(reverse('api_projects_status', kwargs={'object_ptr': sstatus}), **self.authentication_headers)
self.assertEquals(response.status_code, 204)
#delete project
response = self.client.delete(reverse('api_projects', kwargs={'object_ptr': project_id}), **self.authentication_headers)
self.assertEquals(response.status_code, 204)
class EventsViewsTest(TestCase):
"Events functional tests for api"
username = "******"
password = "******"
prepared = False
authentication_headers = {
"CONTENT_TYPE": "application/json",
"HTTP_AUTHORIZATION": "Basic YXBpX3Rlc3Q6YXBpX3Bhc3N3b3Jk"
}
content_type = 'application/json'
def setUp(self):
"Initial Setup"
if not self.prepared:
# Clean up first
Object.objects.all().delete()
# Create objects
try:
self.group = Group.objects.get(name='test')
except Group.DoesNotExist:
Group.objects.all().delete()
self.group = Group(name='test')
self.group.save()
try:
self.user = DjangoUser.objects.get(username=self.username)
self.user.set_password(self.password)
try:
self.profile = self.user.get_profile()
except Exception:
User.objects.all().delete()
self.user = DjangoUser(username=self.username, password='')
self.user.set_password(self.password)
self.user.save()
except DjangoUser.DoesNotExist:
User.objects.all().delete()
self.user = DjangoUser(username=self.username, password='')
self.user.set_password(self.password)
self.user.save()
try:
perspective = Perspective.objects.get(name='default')
except Perspective.DoesNotExist:
Perspective.objects.all().delete()
perspective = Perspective(name='default')
perspective.set_default_user()
perspective.save()
ModuleSetting.set('default_perspective', perspective.id)
self.event = Event(name='TestStatus', end=datetime.now())
self.event.set_default_user()
self.event.save()
self.client = Client()
self.prepared = True
def test_unauthenticated_access(self):
"Test index page at /api/calendar/events"
response = self.client.get('/api/calendar/events')
# Redirects as unauthenticated
self.assertEquals(response.status_code, 401)
def test_get_events_list(self):
""" Test index page api/infrastructure/types """
response = self.client.get(path=reverse('api_events'),
**self.authentication_headers)
self.assertEquals(response.status_code, 200)
def test_get_field(self):
response = self.client.get(path=reverse(
'api_events', kwargs={'object_ptr': self.event.id}),
**self.authentication_headers)
self.assertEquals(response.status_code, 200)
def test_update_field(self):
updates = {
"name": "Api_name",
"details": "Api details",
"start": "2011-03-01 01:12:09",
"end": "2011-03-09 13:05:09"
}
response = self.client.put(path=reverse(
'api_events', kwargs={'object_ptr': self.event.id}),
content_type=self.content_type,
data=json.dumps(updates),
**self.authentication_headers)
self.assertEquals(response.status_code, 200)
data = json.loads(response.content)
self.assertEquals(data['name'], updates['name'])
self.assertEquals(data['details'], updates['details'])
self.assertEquals(data['start'], updates['start'])
self.assertEquals(data['end'], updates['end'])
class MessagingApiTest(TestCase):
"Messaging functional tests for api"
username = "******"
password = "******"
prepared = False
authentication_headers = {
"CONTENT_TYPE": "application/json",
"HTTP_AUTHORIZATION": "Basic YXBpX3Rlc3Q6YXBpX3Bhc3N3b3Jk"
}
content_type = 'application/json'
def setUp(self):
"Initial Setup"
if not self.prepared:
# Clean up first
Object.objects.all().delete()
# Create objects
try:
self.group = Group.objects.get(name='test')
except Group.DoesNotExist:
Group.objects.all().delete()
self.group = Group(name='test')
self.group.save()
try:
self.user = DjangoUser.objects.get(username=self.username)
self.user.set_password(self.password)
try:
self.profile = self.user.get_profile()
except Exception:
User.objects.all().delete()
self.user = DjangoUser(username=self.username, password='')
self.user.set_password(self.password)
self.user.save()
except DjangoUser.DoesNotExist:
User.objects.all().delete()
self.user = DjangoUser(username=self.username, password='')
self.user.set_password(self.password)
self.user.save()
try:
perspective = Perspective.objects.get(name='default')
except Perspective.DoesNotExist:
Perspective.objects.all().delete()
perspective = Perspective(name='default')
perspective.set_default_user()
perspective.save()
ModuleSetting.set('default_perspective', perspective.id)
self.contact_type = ContactType(name='test')
self.contact_type.set_default_user()
self.contact_type.save()
self.contact = Contact(name='test', contact_type=self.contact_type)
self.contact.set_default_user()
self.contact.save()
self.user_contact = Contact(name='test',
related_user=self.user.get_profile(),
contact_type=self.contact_type)
self.user_contact.set_user(self.user)
self.user_contact.save()
self.stream = MessageStream(name='test')
self.stream.set_default_user()
self.stream.save()
self.mlist = MailingList(name='test', from_contact=self.contact)
self.mlist.set_default_user()
self.mlist.save()
self.message = Message(title='test',
body='test',
author=self.contact,
stream=self.stream)
self.message.set_default_user()
self.message.save()
self.client = Client()
self.prepared = True
def test_unauthenticated_access(self):
"Test index page at /api/messaging/mlist"
response = self.client.get('/api/messaging/mlist')
# Redirects as unauthenticated
self.assertEquals(response.status_code, 401)
def test_get_mlist(self):
""" Test index page api/messaging/mlist """
response = self.client.get(path=reverse('api_messaging_mlist'),
**self.authentication_headers)
self.assertEquals(response.status_code, 200)
def test_get_one_mlist(self):
response = self.client.get(path=reverse(
'api_messaging_mlist', kwargs={'object_ptr': self.mlist.id}),
**self.authentication_headers)
self.assertEquals(response.status_code, 200)
def test_update_mlist(self):
updates = {
"name": "API mailing list",
"description": "API description update",
"from_contact": self.contact.id,
"members": [
self.contact.id,
]
}
response = self.client.put(path=reverse(
'api_messaging_mlist', kwargs={'object_ptr': self.mlist.id}),
content_type=self.content_type,
data=json.dumps(updates),
**self.authentication_headers)
self.assertEquals(response.status_code, 200)
data = json.loads(response.content)
self.assertEquals(data['name'], updates['name'])
self.assertEquals(data['description'], updates['description'])
self.assertEquals(data['from_contact']['id'], updates['from_contact'])
for i, member in enumerate(data['members']):
self.assertEquals(member['id'], updates['members'][i])
def test_get_streams(self):
""" Test index page api/messaging/streams """
response = self.client.get(path=reverse('api_messaging_streams'),
**self.authentication_headers)
self.assertEquals(response.status_code, 200)
def test_get_stream(self):
response = self.client.get(path=reverse(
'api_messaging_streams', kwargs={'object_ptr': self.stream.id}),
**self.authentication_headers)
self.assertEquals(response.status_code, 200)
def test_update_stream(self):
updates = {
"name": "API stream",
}
response = self.client.put(path=reverse(
'api_messaging_streams', kwargs={'object_ptr': self.stream.id}),
content_type=self.content_type,
data=json.dumps(updates),
**self.authentication_headers)
self.assertEquals(response.status_code, 200)
data = json.loads(response.content)
self.assertEquals(data['name'], updates['name'])
def test_get_messages(self):
""" Test index page api/messaging/messages """
response = self.client.get(path=reverse('api_messaging_messages'),
**self.authentication_headers)
self.assertEquals(response.status_code, 200)
def test_get_message(self):
response = self.client.get(path=reverse(
'api_messaging_messages', kwargs={'object_ptr': self.message.id}),
**self.authentication_headers)
self.assertEquals(response.status_code, 200)
def test_send_message(self):
updates = {
"title": "API message title",
"body": "Test body",
"stream": self.stream.id,
"multicomplete_recipients": u'*****@*****.**'
}
response = self.client.post(path=reverse('api_messaging_messages'),
content_type=self.content_type,
data=json.dumps(updates),
**self.authentication_headers)
self.assertEquals(response.status_code, 200)
data = json.loads(response.content)
self.assertEquals(data['title'], updates['title'])
self.assertEquals(data['body'], updates['body'])
self.assertEquals(data['stream']['id'], updates['stream'])
def test_reply_to_message(self):
updates = {
"title": "API test",
"body": "Test body",
"stream": self.stream.id,
"multicomplete_recipients": u'*****@*****.**'
}
response = self.client.put(path=reverse(
'api_messaging_messages', kwargs={'object_ptr': self.message.id}),
content_type=self.content_type,
data=json.dumps(updates),
**self.authentication_headers)
self.assertEquals(response.status_code, 200)
data = json.loads(response.content)
self.assertNotEquals(data['title'], updates['title'])
self.assertEquals(data['body'], updates['body'])
self.assertEquals(data['stream']['id'], updates['stream'])
class DocumentsViewsTest(TestCase):
"Documents functional tests for views"
username = "******"
password = "******"
prepared = False
def setUp(self):
"Initial Setup"
if not self.prepared:
Object.objects.all().delete()
# Create objects
try:
self.group = Group.objects.get(name='test')
except Group.DoesNotExist:
Group.objects.all().delete()
self.group = Group(name='test')
self.group.save()
try:
self.user = DjangoUser.objects.get(username=self.username)
self.user.set_password(self.password)
try:
self.profile = self.user.get_profile()
except Exception:
User.objects.all().delete()
self.user = DjangoUser(username=self.username, password='')
self.user.set_password(self.password)
self.user.save()
except DjangoUser.DoesNotExist:
User.objects.all().delete()
self.user = DjangoUser(username=self.username, password='')
self.user.set_password(self.password)
self.user.save()
try:
perspective = Perspective.objects.get(name='default')
except Perspective.DoesNotExist:
Perspective.objects.all().delete()
perspective = Perspective(name='default')
perspective.set_default_user()
perspective.save()
ModuleSetting.set('default_perspective', perspective.id)
self.folder = Folder(name='test')
self.folder.set_default_user()
self.folder.save()
self.document = Document(title='test_document', folder=self.folder)
self.document.set_default_user()
self.document.save()
self.file = File(name='test_file', folder=self.folder)
self.file.set_default_user()
self.file.save()
self.link = WebLink(title='test', folder=self.folder, url='test')
self.link.set_default_user()
self.link.save()
self.client = Client()
self.prepared = True
######################################
# Testing views when user is logged in
######################################
def test_index_login(self):
"Test index page with login at /documents/"
response = self.client.post('/accounts/login',
{'username': self.username, 'password': self.password })
self.assertRedirects(response, '/')
response = self.client.get(reverse('document_index'))
self.assertEquals(response.status_code, 200)
def test_index_documents_login(self):
"Test index page with login at /documents/documents/"
response = self.client.post('/accounts/login',
{'username': self.username, 'password': self.password })
self.assertRedirects(response, '/')
response = self.client.get(reverse('index_documents'))
self.assertEquals(response.status_code, 200)
def test_index_files_login(self):
"Test index page with login at /documents/files/"
response = self.client.post('/accounts/login',
{'username': self.username, 'password': self.password })
self.assertRedirects(response, '/')
response = self.client.get(reverse('index_files'))
self.assertEquals(response.status_code, 200)
def test_index_weblinks_login(self):
"Test index page with login at /documents/weblinks/"
response = self.client.post('/accounts/login',
{'username': self.username, 'password': self.password })
self.assertRedirects(response, '/')
response = self.client.get(reverse('index_weblinks'))
self.assertEquals(response.status_code, 200)
# Folders
def test_folder_add(self):
"Test index page with login at /documents/folder/add/"
response = self.client.post('/accounts/login',
{'username': self.username, 'password': self.password })
self.assertRedirects(response, '/')
response = self.client.get(reverse('documents_folder_add'))
self.assertEquals(response.status_code, 200)
# form
self.assertEqual(Folder.objects.count(), 1)
post_data = {'name': 'test'}
response = self.client.post(reverse('documents_folder_add'), post_data)
self.assertEquals(response.status_code, 302) # redirect somewhere
self.assertEquals(Folder.objects.count(), 2)
def test_folder_view_login(self):
"Test index page with login at /documents/folder/view/<folder_id>"
response = self.client.post('/accounts/login',
{'username': self.username, 'password': self.password })
self.assertRedirects(response, '/')
response = self.client.get(reverse('documents_folder_view', args=[self.folder.id]))
self.assertEquals(response.status_code, 200)
def test_folder_edit_login(self):
"Test index page with login at /documents/folder/edit/<folder_id>"
response = self.client.post('/accounts/login',
{'username': self.username, 'password': self.password })
self.assertRedirects(response, '/')
response = self.client.get(reverse('documents_folder_edit', args=[self.folder.id]))
self.assertEquals(response.status_code, 200)
def test_folder_delete_login(self):
"Test index page with login at /documents/folder/delete/<folder_id>"
response = self.client.post('/accounts/login',
{'username': self.username, 'password': self.password })
self.assertRedirects(response, '/')
response = self.client.get(reverse('documents_folder_delete', args=[self.folder.id]))
self.assertEquals(response.status_code, 200)
# Documents
def test_document_add(self):
"Test index page with login at /documents/add"
response = self.client.post('/accounts/login',
{'username': self.username, 'password': self.password })
self.assertRedirects(response, '/')
response = self.client.get(reverse('documents_document_add'))
self.assertEquals(response.status_code, 200)
# form
self.assertEqual(Document.objects.count(), 1)
response = self.client.get(reverse('documents_document_add'))
post_data = {'title': 'test',
'folder': self.folder,
}
response = self.client.post(reverse('documents_document_add'), post_data)
#self.assertEqual(Document.objects.count(), 2)
def test_document_add_typed(self):
"Test index page with login at /documents/add/folder/<folder_id>"
response = self.client.post('/accounts/login',
{'username': self.username, 'password': self.password })
self.assertRedirects(response, '/')
response = self.client.get(reverse('documents_document_add_typed', args=[self.folder.id]))
self.assertEquals(response.status_code, 200)
def test_document_view_login(self):
"Test index page with login at /documents/view/<document_id>"
response = self.client.post('/accounts/login',
{'username': self.username, 'password': self.password })
self.assertRedirects(response, '/')
response = self.client.get(reverse('documents_document_view', args=[self.document.id]))
self.assertEquals(response.status_code, 200)
def test_document_edit_login(self):
"Test index page with login at /documents/edit/<document_id>"
response = self.client.post('/accounts/login',
{'username': self.username, 'password': self.password })
self.assertRedirects(response, '/')
response = self.client.get(reverse('documents_document_edit', args=[self.document.id]))
self.assertEquals(response.status_code, 200)
def test_document_delete_login(self):
"Test index page with login at /documents/delete/<document_id>"
response = self.client.post('/accounts/login',
{'username': self.username, 'password': self.password })
self.assertRedirects(response, '/')
response = self.client.get(reverse('documents_document_delete', args=[self.document.id]))
self.assertEquals(response.status_code, 200)
# Files
def test_file_view_login(self):
"Test index page with login at /file/view/<file_id>"
response = self.client.post('/accounts/login',
{'username': self.username, 'password': self.password })
self.assertRedirects(response, '/')
response = self.client.get(reverse('documents_file_view', args=[self.file.id]))
self.assertEquals(response.status_code, 200)
def test_file_edit_login(self):
"Test index page with login at /file/edit/<file_id>"
response = self.client.post('/accounts/login',
{'username': self.username, 'password': self.password })
self.assertRedirects(response, '/')
response = self.client.get(reverse('documents_file_edit', args=[self.file.id]))
self.assertEquals(response.status_code, 200)
def test_file_delete_login(self):
"Test index page with login at /file/view/<file_id>"
response = self.client.post('/accounts/login',
{'username': self.username, 'password': self.password })
self.assertRedirects(response, '/')
response = self.client.get(reverse('documents_file_delete', args=[self.file.id]))
self.assertEquals(response.status_code, 200)
# Web Links
def test_weblink_add_typed(self):
"Test index page with login at /documents/weblink/add/<folder_id>"
response = self.client.post('/accounts/login',
{'username': self.username, 'password': self.password })
self.assertRedirects(response, '/')
response = self.client.get(reverse('documents_weblink_add_typed', args=[self.folder.id]))
self.assertEquals(response.status_code, 200)
def test_weblink_add(self):
"Test index page with login at /documents/weblink/add/"
response = self.client.post('/accounts/login',
{'username': self.username, 'password': self.password })
self.assertRedirects(response, '/')
response = self.client.get(reverse('documents_weblink_add'))
self.assertEquals(response.status_code, 200)
# form
self.assertEqual(WebLink.objects.count(), 1)
response = self.client.get(reverse('documents_weblink_add'))
post_data = {'title': 'test',
'folder': self.folder,
'url': 'test',
}
response = self.client.post(reverse('documents_weblink_add'), post_data)
#self.assertEqual(WebLink.objects.count(), 2)
def test_weblink_view_login(self):
"Test index page with login at /documents/view/<weblink_id>"
response = self.client.post('/accounts/login',
{'username': self.username, 'password': self.password })
self.assertRedirects(response, '/')
response = self.client.get(reverse('documents_weblink_view', args=[self.link.id]))
self.assertEquals(response.status_code, 200)
def test_weblink_edit_login(self):
"Test index page with login at /documents/edit/<weblink_id>"
response = self.client.post('/accounts/login',
{'username': self.username, 'password': self.password })
self.assertRedirects(response, '/')
response = self.client.get(reverse('documents_weblink_edit', args=[self.link.id]))
self.assertEquals(response.status_code, 200)
def test_weblink_delete_login(self):
"Test index page with login at /documents/delete/<weblink_id>"
response = self.client.post('/accounts/login',
{'username': self.username, 'password': self.password })
self.assertRedirects(response, '/')
response = self.client.get(reverse('documents_weblink_delete', args=[self.link.id]))
self.assertEquals(response.status_code, 200)
######################################
# Testing views when user is not logged in
######################################
def test_index(self):
"Test index page at /documents/"
response = self.client.get('/documents/')
# Redirects as unauthenticated
self.assertRedirects(response, reverse('user_login'))
def test_index_documents_out(self):
"Testing /documents/documents/"
response = self.client.get(reverse('index_documents'))
self.assertRedirects(response, reverse('user_login'))
def test_index_files_out(self):
"Testing /documents/files/"
response = self.client.get(reverse('index_files'))
self.assertRedirects(response, reverse('user_login'))
def test_index_weblinks_out(self):
"Testing /documents/weblinks/"
response = self.client.get(reverse('index_weblinks'))
self.assertRedirects(response, reverse('user_login'))
# Folders
def test_folder_add_out(self):
"Testing /documents/folder/add/"
response = self.client.get(reverse('documents_folder_add'))
self.assertRedirects(response, reverse('user_login'))
def test_folder_view_out(self):
"Testing /documents/folder/view/<folder_id>"
response = self.client.get(reverse('documents_folder_view', args=[self.folder.id]))
self.assertRedirects(response, reverse('user_login'))
def test_folder_edit_out(self):
"Testing /documents/folder/edit/<folder_id>"
response = self.client.get(reverse('documents_folder_edit', args=[self.folder.id]))
self.assertRedirects(response, reverse('user_login'))
def test_folder_delete_out(self):
"Testing /documents/folder/delete/<folder_id>"
response = self.client.get(reverse('documents_folder_delete', args=[self.folder.id]))
self.assertRedirects(response, reverse('user_login'))
# Documents
def test_document_add_out(self):
"Testing /documents/add"
response = self.client.get(reverse('documents_document_add'))
self.assertRedirects(response, reverse('user_login'))
def test_document_add_typed_out(self):
"Testing /documents/add/folder/<folder_id>"
response = self.client.get(reverse('documents_document_add_typed', args=[self.folder.id]))
self.assertRedirects(response, reverse('user_login'))
def test_document_view_out(self):
"Testing /documents/view/<document_id>"
response = self.client.get(reverse('documents_document_view', args=[self.document.id]))
self.assertRedirects(response, reverse('user_login'))
def test_document_edit_out(self):
"Testing /documents/edit/<document_id>"
response = self.client.get(reverse('documents_document_edit', args=[self.document.id]))
self.assertRedirects(response, reverse('user_login'))
def test_document_delete_out(self):
"Testing /documents/delete/<document_id>"
response = self.client.get(reverse('documents_document_delete', args=[self.document.id]))
self.assertRedirects(response, reverse('user_login'))
# Files
def test_file_view_out(self):
"Testing /file/view/<file_id>"
response = self.client.get(reverse('documents_file_view', args=[self.file.id]))
self.assertRedirects(response, reverse('user_login'))
def test_file_edit_out(self):
"Testing /file/edit/<file_id>"
response = self.client.get(reverse('documents_file_edit', args=[self.file.id]))
self.assertRedirects(response, reverse('user_login'))
def test_file_delete_out(self):
"Testing /file/view/<file_id>"
response = self.client.get(reverse('documents_file_delete', args=[self.file.id]))
self.assertRedirects(response, reverse('user_login'))
# Web Links
def test_weblink_add_typed_out(self):
"Testing /documents/weblink/add/<folder_id>"
response = self.client.get(reverse('documents_weblink_add_typed', args=[self.folder.id]))
self.assertRedirects(response, reverse('user_login'))
def test_weblink_add_out(self):
"Testing /documents/weblink/add/"
response = self.client.get(reverse('documents_weblink_add'))
self.assertRedirects(response, reverse('user_login'))
def test_weblink_view_out(self):
"Testing /documents/view/<weblink_id>"
response = self.client.get(reverse('documents_weblink_view', args=[self.link.id]))
self.assertRedirects(response, reverse('user_login'))
def test_weblink_edit_out(self):
"Testing /documents/edit/<weblink_id>"
response = self.client.get(reverse('documents_weblink_edit', args=[self.link.id]))
self.assertRedirects(response, reverse('user_login'))
def test_weblink_delete_out(self):
"Testing /documents/delete/<weblink_id>"
response = self.client.get(reverse('documents_weblink_delete', args=[self.link.id]))
self.assertRedirects(response, reverse('user_login'))
class MiddlewareChatTest(TestCase):
"Midleware chat tests"
username = "******"
password = "******"
prepared = False
def setUp(self):
"Initial Setup"
if not self.prepared:
Object.objects.all().delete()
# Create objects
try:
self.group = Group.objects.get(name='test')
except Group.DoesNotExist:
Group.objects.all().delete()
self.group = Group(name='test')
self.group.save()
try:
self.user = DjangoUser.objects.get(username=self.username)
self.user.set_password(self.password)
try:
self.profile = self.user.get_profile()
except Exception:
User.objects.all().delete()
self.user = DjangoUser(username=self.username, password='')
self.user.set_password(self.password)
self.user.save()
except DjangoUser.DoesNotExist:
User.objects.all().delete()
self.user = DjangoUser(username=self.username, password='')
self.user.set_password(self.password)
self.user.save()
try:
perspective = Perspective.objects.get(name='default')
except Perspective.DoesNotExist:
Perspective.objects.all().delete()
perspective = Perspective(name='default')
perspective.set_default_user()
perspective.save()
ModuleSetting.set('default_perspective', perspective.id)
self.client = Client()
self.prepared = True
def test_chat_get_new_messages(self):
"Test get_new_messages"
response = self.client.post('/chat', {'json': '{"cmd":"Get", "location":"#"}'})
self.assertEqual(response.status_code, 200)
def test_chat_connect(self):
"Test connect"
response = self.client.post('/chat', {'json': '{"cmd":"Connect", "location":"#"}'})
self.assertEqual(response.status_code, 200)
def test_chat_disconnect(self):
"Test disconnect"
response = self.client.post('/chat', {'json': '{"cmd":"Disconnect", "location":"#"}'})
self.assertEqual(response.status_code, 200)
def test_chat_add_new_message(self):
"Test add_new_message"
response = self.client.post('/chat', {'json': '{"cmd":"Message","data":{"id":"test_b5e6d0470a5f4656c3bc77f879c3dbbc","text":"test message"},"location":"#"}'})
self.assertEqual(response.status_code, 200)
def test_chat_exit_from_conference(self):
"Test exit_from_conference"
response = self.client.post('/chat', {'json': '{"cmd":"Exit","data":{"id":"test_b5e6d0470a5f4656c3bc77f879c3dbbc"},"location":"#"}'})
self.assertEqual(response.status_code, 200)
def test_chat_add_users_in_conference(self):
"Test add_users_in_conference"
response = self.client.post('/chat', {'json': '{"cmd":"Add","data":{"id":"guest_006f721c4a59a44d969b9f73fb6360a5","users":["test"]},"location":"#"}'})
self.assertEqual(response.status_code, 200)
def test_chat_create_conference(self):
"Test create_conference"
response = self.client.post('/chat', {'json': '{"cmd":"Create","data":{"title":["Admin"],"users":["admin"]},"location":"#"}'})
self.assertEqual(response.status_code, 200)
class FinanceAPITest(TestCase):
"Finance api tests"
username = "******"
password = "******"
prepared = False
authentication_headers = {"CONTENT_TYPE": "application/json",
"HTTP_AUTHORIZATION": "Basic YXBpX3Rlc3Q6YXBpX3Bhc3N3b3Jk"}
content_type = 'application/json'
def setUp(self):
"Initial Setup"
if not self.prepared:
# Clean up first
Object.objects.all().delete()
User.objects.all().delete()
# Create objects
try:
self.group = Group.objects.get(name='test')
except Group.DoesNotExist:
Group.objects.all().delete()
self.group = Group(name='test')
self.group.save()
try:
self.user = DjangoUser.objects.get(username=self.username)
self.user.set_password(self.password)
try:
self.profile = self.user.get_profile()
except Exception:
User.objects.all().delete()
self.user = DjangoUser(username=self.username, password='')
self.user.set_password(self.password)
self.user.save()
except DjangoUser.DoesNotExist:
User.objects.all().delete()
self.user = DjangoUser(username=self.username, password='')
self.user.set_password(self.password)
self.user.save()
try:
perspective = Perspective.objects.get(name='default')
except Perspective.DoesNotExist:
Perspective.objects.all().delete()
perspective = Perspective(name='default')
perspective.set_default_user()
perspective.save()
ModuleSetting.set('default_perspective', perspective.id)
self.contact_type = ContactType(name='test')
self.contact_type.set_default_user()
self.contact_type.save()
self.contact = Contact(name='test', contact_type=self.contact_type)
self.contact.set_default_user()
self.contact.save()
self.category = Category(name='test')
self.category.set_default_user()
self.category.save()
self.equity = Equity(
issue_price=10, sell_price=10, issuer=self.contact, owner=self.contact)
self.equity.set_default_user()
self.equity.save()
self.asset = Asset(name='test', owner=self.contact)
self.asset.set_default_user()
self.asset.save()
self.tax = Tax(name='test', rate=10)
self.tax.set_default_user()
self.tax.save()
self.currency = Currency(code="GBP",
name="Pounds",
symbol="L",
is_default=True)
self.currency.set_default_user()
self.currency.save()
self.account = Account(
name='test', owner=self.contact, balance_currency=self.currency)
self.account.set_default_user()
self.account.save()
self.liability = Liability(name='test',
source=self.contact,
target=self.contact,
account=self.account,
value=10,
value_currency=self.currency)
self.liability.set_default_user()
self.liability.save()
self.transaction = Transaction(name='test', account=self.account, source=self.contact,
target=self.contact, value=10, value_currency=self.currency)
self.transaction.set_default_user()
self.transaction.save()
self.client = Client()
self.prepared = True
def test_unauthenticated_access(self):
"Test index page at /api/finance/currencies"
response = self.client.get('/api/finance/currencies')
# Redirects as unauthenticated
self.assertEquals(response.status_code, 401)
def test_get_currencies_list(self):
""" Test index page api/finance/currencies """
response = self.client.get(
path=reverse('api_finance_currencies'), **self.authentication_headers)
self.assertEquals(response.status_code, 200)
def test_get_currency(self):
response = self.client.get(path=reverse('api_finance_currencies', kwargs={
'object_ptr': self.currency.id}), **self.authentication_headers)
self.assertEquals(response.status_code, 200)
def test_update_currency(self):
updates = {"code": "RUB", "name": "api RUB",
"factor": "10.00", "is_active": True}
response = self.client.put(path=reverse('api_finance_currencies', kwargs={'object_ptr': self.currency.id}),
content_type=self.content_type, data=json.dumps(updates), **self.authentication_headers)
self.assertEquals(response.status_code, 200)
data = json.loads(response.content)
self.assertEquals(data['code'], updates['code'])
self.assertEquals(data['name'], updates['name'])
self.assertEquals(data['factor'], updates['factor'])
self.assertEquals(data['is_active'], updates['is_active'])
def test_get_taxes_list(self):
""" Test index page api/finance/taxes """
response = self.client.get(
path=reverse('api_finance_taxes'), **self.authentication_headers)
self.assertEquals(response.status_code, 200)
def test_get_tax(self):
response = self.client.get(path=reverse(
'api_finance_taxes', kwargs={'object_ptr': self.tax.id}), **self.authentication_headers)
self.assertEquals(response.status_code, 200)
def test_update_tax(self):
updates = {"name": "API TEST TAX", "rate": "20.00", "compound": False}
response = self.client.put(path=reverse('api_finance_taxes', kwargs={'object_ptr': self.tax.id}),
content_type=self.content_type, data=json.dumps(updates), **self.authentication_headers)
self.assertEquals(response.status_code, 200)
data = json.loads(response.content)
self.assertEquals(data['name'], updates['name'])
self.assertEquals(data['rate'], updates['rate'])
self.assertEquals(data['compound'], updates['compound'])
def test_get_categories_list(self):
""" Test index page api/finance/categories """
response = self.client.get(
path=reverse('api_finance_categories'), **self.authentication_headers)
self.assertEquals(response.status_code, 200)
def test_get_category(self):
response = self.client.get(path=reverse('api_finance_categories', kwargs={
'object_ptr': self.category.id}), **self.authentication_headers)
self.assertEquals(response.status_code, 200)
def test_update_category(self):
updates = {"name": "Api category", "details": "api details"}
response = self.client.put(path=reverse('api_finance_categories', kwargs={'object_ptr': self.category.id}),
content_type=self.content_type, data=json.dumps(updates), **self.authentication_headers)
self.assertEquals(response.status_code, 200)
data = json.loads(response.content)
self.assertEquals(data['name'], updates['name'])
self.assertEquals(data['details'], updates['details'])
def test_get_assets_list(self):
""" Test index page api/finance/assets """
response = self.client.get(
path=reverse('api_finance_assets'), **self.authentication_headers)
self.assertEquals(response.status_code, 200)
def test_get_asset(self):
response = self.client.get(path=reverse('api_finance_assets', kwargs={
'object_ptr': self.asset.id}), **self.authentication_headers)
self.assertEquals(response.status_code, 200)
def test_update_asset(self):
updates = {"current_value": "20.0", "owner": self.contact.id, "asset_type": "fixed", "name": "Api name",
"initial_value": '40.0'}
response = self.client.put(path=reverse('api_finance_assets', kwargs={'object_ptr': self.asset.id}),
content_type=self.content_type, data=json.dumps(updates), **self.authentication_headers)
print response.content
self.assertEquals(response.status_code, 200)
data = json.loads(response.content)
self.assertEquals(data['name'], updates['name'])
self.assertEquals(data['owner']['id'], updates['owner'])
self.assertEquals(data['asset_type'], updates['asset_type'])
self.assertEquals(data['initial_value'], updates['initial_value'])
self.assertEquals(data['current_value'], updates['current_value'])
def test_get_accounts_list(self):
""" Test index page api/finance/accounts """
response = self.client.get(
path=reverse('api_finance_accounts'), **self.authentication_headers)
self.assertEquals(response.status_code, 200)
def test_get_account(self):
response = self.client.get(path=reverse('api_finance_accounts', kwargs={
'object_ptr': self.account.id}), **self.authentication_headers)
self.assertEquals(response.status_code, 200)
def test_update_account(self):
updates = {"owner": self.user.id, "balance_display": 40.0,
"name": "api test name", "balance_currency": self.currency.id}
response = self.client.put(path=reverse('api_finance_accounts', kwargs={'object_ptr': self.account.id}),
content_type=self.content_type, data=json.dumps(updates), **self.authentication_headers)
self.assertEquals(response.status_code, 200)
data = json.loads(response.content)
self.assertEquals(data['name'], updates['name'])
self.assertEquals(data['owner']['id'], updates['owner'])
self.assertEquals(data['balance_display'], updates['balance_display'])
self.assertEquals(
data['balance_currency']['id'], updates['balance_currency'])
def test_get_equities_list(self):
""" Test index page api/finance/equities"""
response = self.client.get(
path=reverse('api_finance_equities'), **self.authentication_headers)
self.assertEquals(response.status_code, 200)
def test_get_equity(self):
response = self.client.get(path=reverse('api_finance_equities', kwargs={
'object_ptr': self.equity.id}), **self.authentication_headers)
self.assertEquals(response.status_code, 200)
def test_update_account_2(self):
updates = {"issue_price": "100.0", "equity_type": "warrant", "sell_price": "50.0", "amount": 100,
"purchase_date": "2011-06-06", "owner": self.contact.id, "issuer": self.contact.id}
response = self.client.put(path=reverse('api_finance_equities', kwargs={'object_ptr': self.equity.id}),
content_type=self.content_type, data=json.dumps(updates), **self.authentication_headers)
self.assertEquals(response.status_code, 200)
data = json.loads(response.content)
self.assertEquals(data['issue_price'], updates['issue_price'])
self.assertEquals(data['equity_type'], updates['equity_type'])
self.assertEquals(data['sell_price'], updates['sell_price'])
self.assertEquals(data['amount'], updates['amount'])
self.assertEquals(data['purchase_date'], updates['purchase_date'])
self.assertEquals(data['owner']['id'], updates['owner'])
self.assertEquals(data['issuer']['id'], updates['issuer'])
self.assertEquals(data['issuer']['id'], updates['issuer'])
def test_get_liabilities_list(self):
""" Test index page api/finance/liabilities"""
response = self.client.get(
path=reverse('api_finance_liabilities'), **self.authentication_headers)
self.assertEquals(response.status_code, 200)
def test_get_liability(self):
response = self.client.get(path=reverse('api_finance_liabilities', kwargs={
'object_ptr': self.liability.id}), **self.authentication_headers)
self.assertEquals(response.status_code, 200)
def test_update_liability(self):
updates = {"account": self.account.id, "target": self.contact.id, "value_display": "20.0",
"name": "api test name", "value_currency": self.currency.id}
response = self.client.put(path=reverse('api_finance_liabilities', kwargs={'object_ptr': self.liability.id}),
content_type=self.content_type, data=json.dumps(updates), **self.authentication_headers)
self.assertEquals(response.status_code, 200)
data = json.loads(response.content)
self.assertEquals(data['name'], updates['name'])
self.assertEquals(data['target']['id'], updates['target'])
self.assertEquals(data['account']['id'], updates['account'])
self.assertEquals(data['value_display'], updates['value_display'])
self.assertEquals(
data['value_currency']['id'], updates['value_currency'])
def test_get_transactions_list(self):
""" Test index page api/finance/transactions"""
response = self.client.get(
path=reverse('api_finance_transactions'), **self.authentication_headers)
self.assertEquals(response.status_code, 200)
def test_get_transaction(self):
response = self.client.get(path=reverse('api_finance_transactions', kwargs={
'object_ptr': self.transaction.id}), **self.authentication_headers)
self.assertEquals(response.status_code, 200)
def test_update_transaction(self):
updates = {"value_display": "1000.0", "account": self.account.id, "name": "api test name", "value_currency": self.currency.id,
"datetime": "2011-03-21 11:04:42", "target": self.contact.id, "account": self.account.id, "source": self.contact.id}
response = self.client.put(path=reverse('api_finance_transactions', kwargs={'object_ptr': self.transaction.id}),
content_type=self.content_type, data=json.dumps(updates), **self.authentication_headers)
print response.content
self.assertEquals(response.status_code, 200)
data = json.loads(response.content)
self.assertEquals(data['name'], updates['name'])
self.assertEquals(data['value_display'], updates['value_display'])
self.assertEquals(data['account']['id'], updates['account'])
self.assertEquals(
data['value_currency']['id'], updates['value_currency'])
self.assertEquals(data['datetime'], updates['datetime'])
self.assertEquals(data['target']['id'], updates['target'])
self.assertEquals(data['account']['id'], updates['account'])
self.assertEquals(data['source']['id'], updates['source'])
class FinanceAPITest(TestCase):
"Finance api tests"
username = "******"
password = "******"
prepared = False
authentication_headers ={"CONTENT_TYPE": "application/json",
"HTTP_AUTHORIZATION" : "Basic YXBpX3Rlc3Q6YXBpX3Bhc3N3b3Jk" }
content_type ='application/json'
def setUp(self):
"Initial Setup"
if not self.prepared:
# Clean up first
Object.objects.all().delete()
User.objects.all().delete()
# Create objects
try:
self.group = Group.objects.get(name='test')
except Group.DoesNotExist:
Group.objects.all().delete()
self.group = Group(name='test')
self.group.save()
try:
self.user = DjangoUser.objects.get(username=self.username)
self.user.set_password(self.password)
try:
self.profile = self.user.get_profile()
except Exception:
User.objects.all().delete()
self.user = DjangoUser(username=self.username, password='')
self.user.set_password(self.password)
self.user.save()
except DjangoUser.DoesNotExist:
User.objects.all().delete()
self.user = DjangoUser(username=self.username, password='')
self.user.set_password(self.password)
self.user.save()
try:
perspective = Perspective.objects.get(name='default')
except Perspective.DoesNotExist:
Perspective.objects.all().delete()
perspective = Perspective(name='default')
perspective.set_default_user()
perspective.save()
ModuleSetting.set('default_perspective', perspective.id)
self.contact_type = ContactType(name='test')
self.contact_type.set_default_user()
self.contact_type.save()
self.contact = Contact(name='test', contact_type=self.contact_type)
self.contact.set_default_user()
self.contact.save()
self.category = Category(name='test')
self.category.set_default_user()
self.category.save()
self.equity = Equity(issue_price=10, sell_price=10, issuer=self.contact, owner=self.contact)
self.equity.set_default_user()
self.equity.save()
self.asset = Asset(name='test', owner=self.contact)
self.asset.set_default_user()
self.asset.save()
self.tax = Tax(name='test', rate=10)
self.tax.set_default_user()
self.tax.save()
self.currency = Currency(code="GBP",
name="Pounds",
symbol="L",
is_default=True)
self.currency.set_default_user()
self.currency.save()
self.account = Account(name='test', owner=self.contact, balance_currency=self.currency)
self.account.set_default_user()
self.account.save()
self.liability = Liability(name='test',
source=self.contact,
target=self.contact,
account=self.account,
value=10,
value_currency=self.currency)
self.liability.set_default_user()
self.liability.save()
self.transaction = Transaction(name='test', account=self.account, source=self.contact,
target=self.contact, value=10, value_currency=self.currency)
self.transaction.set_default_user()
self.transaction.save()
self.client = Client()
self.prepared = True
def test_unauthenticated_access(self):
"Test index page at /api/finance/currencies"
response = self.client.get('/api/finance/currencies')
# Redirects as unauthenticated
self.assertEquals(response.status_code, 401)
def test_get_currencies_list(self):
""" Test index page api/finance/currencies """
response = self.client.get(path=reverse('api_finance_currencies'), **self.authentication_headers)
self.assertEquals(response.status_code, 200)
def test_get_currency(self):
response = self.client.get(path=reverse('api_finance_currencies', kwargs={'object_ptr': self.currency.id}), **self.authentication_headers)
self.assertEquals(response.status_code, 200)
def test_update_currency(self):
updates = {"code": "RUB", "name": "api RUB", "factor": "10.00", "is_active": True}
response = self.client.put(path=reverse('api_finance_currencies', kwargs={'object_ptr': self.currency.id}),
content_type=self.content_type, data=json.dumps(updates), **self.authentication_headers)
self.assertEquals(response.status_code, 200)
data = json.loads(response.content)
self.assertEquals(data['code'], updates['code'])
self.assertEquals(data['name'], updates['name'])
self.assertEquals(data['factor'], updates['factor'])
self.assertEquals(data['is_active'], updates['is_active'])
def test_get_taxes_list(self):
""" Test index page api/finance/taxes """
response = self.client.get(path=reverse('api_finance_taxes'), **self.authentication_headers)
self.assertEquals(response.status_code, 200)
def test_get_tax(self):
response = self.client.get(path=reverse('api_finance_taxes', kwargs={'object_ptr': self.tax.id}), **self.authentication_headers)
self.assertEquals(response.status_code, 200)
def test_update_tax(self):
updates = { "name" : "API TEST TAX", "rate": "20.00", "compound": False}
response = self.client.put(path=reverse('api_finance_taxes', kwargs={'object_ptr': self.tax.id}),
content_type=self.content_type, data=json.dumps(updates), **self.authentication_headers)
self.assertEquals(response.status_code, 200)
data = json.loads(response.content)
self.assertEquals(data['name'], updates['name'])
self.assertEquals(data['rate'], updates['rate'])
self.assertEquals(data['compound'], updates['compound'])
def test_get_categories_list(self):
""" Test index page api/finance/categories """
response = self.client.get(path=reverse('api_finance_categories'), **self.authentication_headers)
self.assertEquals(response.status_code, 200)
def test_get_category(self):
response = self.client.get(path=reverse('api_finance_categories', kwargs={'object_ptr': self.category.id}), **self.authentication_headers)
self.assertEquals(response.status_code, 200)
def test_update_category(self):
updates = { "name":"Api category", "details": "api details" }
response = self.client.put(path=reverse('api_finance_categories', kwargs={'object_ptr': self.category.id}),
content_type=self.content_type, data=json.dumps(updates), **self.authentication_headers)
self.assertEquals(response.status_code, 200)
data = json.loads(response.content)
self.assertEquals(data['name'], updates['name'])
self.assertEquals(data['details'], updates['details'])
def test_get_assets_list(self):
""" Test index page api/finance/assets """
response = self.client.get(path=reverse('api_finance_assets'), **self.authentication_headers)
self.assertEquals(response.status_code, 200)
def test_get_asset(self):
response = self.client.get(path=reverse('api_finance_assets', kwargs={'object_ptr': self.asset.id}), **self.authentication_headers)
self.assertEquals(response.status_code, 200)
def test_update_asset(self):
updates = { "current_value": "20.0", "owner": self.contact.id, "asset_type": "fixed", "name": "Api name",
"initial_value": '40.0'}
response = self.client.put(path=reverse('api_finance_assets', kwargs={'object_ptr': self.asset.id}),
content_type=self.content_type, data=json.dumps(updates), **self.authentication_headers)
print response.content
self.assertEquals(response.status_code, 200)
data = json.loads(response.content)
self.assertEquals(data['name'], updates['name'])
self.assertEquals(data['owner']['id'], updates['owner'])
self.assertEquals(data['asset_type'], updates['asset_type'])
self.assertEquals(data['initial_value'], updates['initial_value'])
self.assertEquals(data['current_value'], updates['current_value'])
def test_get_accounts_list(self):
""" Test index page api/finance/accounts """
response = self.client.get(path=reverse('api_finance_accounts'), **self.authentication_headers)
self.assertEquals(response.status_code, 200)
def test_get_account(self):
response = self.client.get(path=reverse('api_finance_accounts', kwargs={'object_ptr': self.account.id}), **self.authentication_headers)
self.assertEquals(response.status_code, 200)
def test_update_account(self):
updates = { "owner": self.user.id, "balance_display": 40.0, "name": "api test name", "balance_currency": self.currency.id }
response = self.client.put(path=reverse('api_finance_accounts', kwargs={'object_ptr': self.account.id}),
content_type=self.content_type, data=json.dumps(updates), **self.authentication_headers)
self.assertEquals(response.status_code, 200)
data = json.loads(response.content)
self.assertEquals(data['name'], updates['name'])
self.assertEquals(data['owner']['id'], updates['owner'])
self.assertEquals(data['balance_display'], updates['balance_display'])
self.assertEquals(data['balance_currency']['id'], updates['balance_currency'])
def test_get_equities_list(self):
""" Test index page api/finance/equities"""
response = self.client.get(path=reverse('api_finance_equities'), **self.authentication_headers)
self.assertEquals(response.status_code, 200)
def test_get_equity(self):
response = self.client.get(path=reverse('api_finance_equities', kwargs={'object_ptr': self.equity.id}), **self.authentication_headers)
self.assertEquals(response.status_code, 200)
def test_update_account(self):
updates = { "issue_price": "100.0", "equity_type": "warrant", "sell_price": "50.0", "amount": 100,
"purchase_date": "2011-06-06", "owner": self.contact.id, "issuer": self.contact.id }
response = self.client.put(path=reverse('api_finance_equities', kwargs={'object_ptr': self.equity.id}),
content_type=self.content_type, data=json.dumps(updates), **self.authentication_headers)
self.assertEquals(response.status_code, 200)
data = json.loads(response.content)
self.assertEquals(data['issue_price'], updates['issue_price'])
self.assertEquals(data['equity_type'], updates['equity_type'])
self.assertEquals(data['sell_price'], updates['sell_price'])
self.assertEquals(data['amount'], updates['amount'])
self.assertEquals(data['purchase_date'], updates['purchase_date'])
self.assertEquals(data['owner']['id'], updates['owner'])
self.assertEquals(data['issuer']['id'], updates['issuer'])
self.assertEquals(data['issuer']['id'], updates['issuer'])
def test_get_liabilities_list(self):
""" Test index page api/finance/liabilities"""
response = self.client.get(path=reverse('api_finance_liabilities'), **self.authentication_headers)
self.assertEquals(response.status_code, 200)
def test_get_liability(self):
response = self.client.get(path=reverse('api_finance_liabilities', kwargs={'object_ptr': self.liability.id}), **self.authentication_headers)
self.assertEquals(response.status_code, 200)
def test_update_liability(self):
updates = { "account": self.account.id, "target": self.contact.id, "value_display": "20.0",
"name": "api test name", "value_currency": self.currency.id}
response = self.client.put(path=reverse('api_finance_liabilities', kwargs={'object_ptr': self.liability.id}),
content_type=self.content_type, data=json.dumps(updates), **self.authentication_headers)
self.assertEquals(response.status_code, 200)
data = json.loads(response.content)
self.assertEquals(data['name'], updates['name'])
self.assertEquals(data['target']['id'], updates['target'])
self.assertEquals(data['account']['id'], updates['account'])
self.assertEquals(data['value_display'], updates['value_display'])
self.assertEquals(data['value_currency']['id'], updates['value_currency'])
def test_get_transactions_list(self):
""" Test index page api/finance/transactions"""
response = self.client.get(path=reverse('api_finance_transactions'), **self.authentication_headers)
self.assertEquals(response.status_code, 200)
def test_get_transaction(self):
response = self.client.get(path=reverse('api_finance_transactions', kwargs={'object_ptr': self.transaction.id}), **self.authentication_headers)
self.assertEquals(response.status_code, 200)
def test_update_transaction(self):
updates = { "value_display": "1000.0", "account": self.account.id, "name": "api test name", "value_currency": self.currency.id,
"datetime": "2011-03-21 11:04:42", "target": self.contact.id, "account": self.account.id, "source": self.contact.id }
response = self.client.put(path=reverse('api_finance_transactions', kwargs={'object_ptr': self.transaction.id}),
content_type=self.content_type, data=json.dumps(updates), **self.authentication_headers)
print response.content
self.assertEquals(response.status_code, 200)
data = json.loads(response.content)
self.assertEquals(data['name'], updates['name'])
self.assertEquals(data['value_display'], updates['value_display'])
self.assertEquals(data['account']['id'], updates['account'])
self.assertEquals(data['value_currency']['id'], updates['value_currency'])
self.assertEquals(data['datetime'], updates['datetime'])
self.assertEquals(data['target']['id'], updates['target'])
self.assertEquals(data['account']['id'], updates['account'])
self.assertEquals(data['source']['id'], updates['source'])
class ProjectsViewsTest(TestCase):
"Projects functional tests for views"
username = "******"
password = "******"
prepared = False
def setUp(self):
"Initial Setup"
if not self.prepared:
# Clean up first
Object.objects.all().delete()
User.objects.all().delete()
# Create objects
try:
self.group = Group.objects.get(name='test')
except Group.DoesNotExist:
Group.objects.all().delete()
self.group = Group(name='test')
self.group.save()
try:
self.user = DjangoUser.objects.get(username=self.username)
self.user.set_password(self.password)
try:
self.profile = self.user.get_profile()
except Exception:
User.objects.all().delete()
self.user = DjangoUser(username=self.username, password='')
self.user.set_password(self.password)
self.user.save()
except DjangoUser.DoesNotExist:
User.objects.all().delete()
self.user = DjangoUser(username=self.username, password='')
self.user.set_password(self.password)
self.user.save()
try:
perspective = Perspective.objects.get(name='default')
except Perspective.DoesNotExist:
Perspective.objects.all().delete()
perspective = Perspective(name='default')
perspective.set_default_user()
perspective.save()
ModuleSetting.set('default_perspective', perspective.id)
self.contact_type = ContactType(name='test')
self.contact_type.set_default_user()
self.contact_type.save()
self.contact = Contact(name='test', contact_type=self.contact_type)
self.contact.set_default_user()
self.contact.save()
self.project = Project(name='test', manager=self.contact, client=self.contact)
self.project.set_default_user()
self.project.save()
self.status = TaskStatus(name='test')
self.status.set_default_user()
self.status.save()
self.milestone = Milestone(name='test', project=self.project, status=self.status)
self.milestone.set_default_user()
self.milestone.save()
self.task = Task(name='test', project=self.project, status=self.status, priority=3)
self.task.set_default_user()
self.task.save()
self.time_slot = TaskTimeSlot(task=self.task, details='test', time_from=datetime.now(), user=self.user.get_profile())
self.time_slot.set_default_user()
self.time_slot.save()
self.parent = Project(name='test')
self.parent.set_default_user()
self.parent.save()
self.parent_task = Task(name='test', project=self.project, status=self.status, priority=3)
self.parent_task.set_default_user()
self.parent_task.save()
self.client = Client()
self.prepared = True
######################################
# Testing views when user is logged in
######################################
def test_index_login(self):
"Test index page with login at /projects/"
response = self.client.post('/accounts/login',
{'username': self.username, 'password': self.password })
self.assertRedirects(response, '/')
response = self.client.get(reverse('projects'))
self.assertEquals(response.status_code, 200)
# Projects
def test_project_add(self):
"Test index page with login at /projects/add/"
response = self.client.post('/accounts/login',
{'username': self.username, 'password': self.password })
self.assertRedirects(response, '/')
response = self.client.get(reverse('project_add'))
self.assertEquals(response.status_code, 200)
def test_project_add_typed(self):
"Test index page with login at /projects/add/<project_id>/"
response = self.client.post('/accounts/login',
{'username': self.username, 'password': self.password })
self.assertRedirects(response, '/')
response = self.client.get(reverse('projects_project_add_typed', args=[self.parent.id]))
self.assertEquals(response.status_code, 200)
def test_project_view_login(self):
"Test index page with login at /projects/view/<project_id>"
response = self.client.post('/accounts/login',
{'username': self.username, 'password': self.password })
self.assertRedirects(response, '/')
response = self.client.get(reverse('projects_project_view', args=[self.project.id]))
self.assertEquals(response.status_code, 200)
def test_project_edit_login(self):
"Test index page with login at /projects/edit//<project_id>"
response = self.client.post('/accounts/login',
{'username': self.username, 'password': self.password })
self.assertRedirects(response, '/')
response = self.client.get(reverse('projects_project_edit', args=[self.project.id]))
self.assertEquals(response.status_code, 200)
def test_project_delete_login(self):
"Test index page with login at /projects/delete//<project_id>"
response = self.client.post('/accounts/login',
{'username': self.username, 'password': self.password })
self.assertRedirects(response, '/')
response = self.client.get(reverse('projects_project_delete', args=[self.project.id]))
self.assertEquals(response.status_code, 200)
# Milestones
def test_milestone_add(self):
"Test index page with login at /projects/milestone/add"
response = self.client.post('/accounts/login',
{'username': self.username, 'password': self.password })
self.assertRedirects(response, '/')
response = self.client.get(reverse('projects_milestone_add'))
self.assertEquals(response.status_code, 200)
def test_milestone_add_typed(self):
"Test index page with login at /projects/milestone/add/<project_id>"
response = self.client.post('/accounts/login',
{'username': self.username, 'password': self.password })
self.assertRedirects(response, '/')
response = self.client.get(reverse('projects_milestone_add_typed', args=[self.parent.id]))
self.assertEquals(response.status_code, 200)
def test_milestone_view_login(self):
"Test index page with login at /projects/milestone/view/<milestone_id>"
response = self.client.post('/accounts/login',
{'username': self.username, 'password': self.password })
self.assertRedirects(response, '/')
response = self.client.get(reverse('projects_milestone_view', args=[self.milestone.id]))
self.assertEquals(response.status_code, 200)
def test_milestone_edit_login(self):
"Test index page with login at /projects/milestone/edit/<milestone_id>"
response = self.client.post('/accounts/login',
{'username': self.username, 'password': self.password })
self.assertRedirects(response, '/')
response = self.client.get(reverse('projects_milestone_edit', args=[self.milestone.id]))
self.assertEquals(response.status_code, 200)
def test_milestone_delete_login(self):
"Test index page with login at /projects/milestone/delete/<milestone_id>"
response = self.client.post('/accounts/login',
{'username': self.username, 'password': self.password })
self.assertRedirects(response, '/')
response = self.client.get(reverse('projects_milestone_delete', args=[self.milestone.id]))
self.assertEquals(response.status_code, 200)
# Tasks
def test_task_add(self):
"Test index page with login at /projects/task/add/"
response = self.client.post('/accounts/login',
{'username': self.username, 'password': self.password })
self.assertRedirects(response, '/')
response = self.client.get(reverse('projects_task_add'))
self.assertEquals(response.status_code, 200)
def test_task_add_typed(self):
"Test index page with login at /projects/task/add/<project_id>"
response = self.client.post('/accounts/login',
{'username': self.username, 'password': self.password })
self.assertRedirects(response, '/')
response = self.client.get(reverse('projects_task_add_typed', args=[self.project.id]))
self.assertEquals(response.status_code, 200)
def test_task_add_to_milestone(self):
"Test index page with login at /projects/task/add/<milestone_id>"
response = self.client.post('/accounts/login',
{'username': self.username, 'password': self.password })
self.assertRedirects(response, '/')
response = self.client.get(reverse('projects_task_add_to_milestone', args=[self.milestone.id]))
self.assertEquals(response.status_code, 200)
def test_task_add_subtask(self):
"Test index page with login at /projects/task/add/<task_id>/"
response = self.client.post('/accounts/login',
{'username': self.username, 'password': self.password })
self.assertRedirects(response, '/')
response = self.client.get(reverse('projects_task_add_subtask', args=[self.parent_task.id]))
self.assertEquals(response.status_code, 200)
def test_task_set_status(self):
"Test index page with login at /projects/task/add/<task_id>/status/<status_id>"
response = self.client.post('/accounts/login',
{'username': self.username, 'password': self.password })
self.assertRedirects(response, '/')
response = self.client.get(reverse('projects_task_set_status', args=[self.task.id, self.status.id]))
self.assertEquals(response.status_code, 200)
def test_task_view_login(self):
"Test index page with login at /projects/task/view/<task_id>"
response = self.client.post('/accounts/login',
{'username': self.username, 'password': self.password })
self.assertRedirects(response, '/')
response = self.client.get(reverse('projects_task_view', args=[self.task.id]))
self.assertEquals(response.status_code, 200)
def test_task_edit_login(self):
"Test index page with login at /projects/task/edit/<task_id>"
response = self.client.post('/accounts/login',
{'username': self.username, 'password': self.password })
self.assertRedirects(response, '/')
response = self.client.get(reverse('projects_task_edit', args=[self.task.id]))
self.assertEquals(response.status_code, 200)
def test_task_delete_login(self):
"Test index page with login at /projects/task/delete/<task_id>"
response = self.client.post('/accounts/login',
{'username': self.username, 'password': self.password })
self.assertRedirects(response, '/')
response = self.client.get(reverse('projects_task_delete', args=[self.task.id]))
self.assertEquals(response.status_code, 200)
# Task Time Slots
def test_time_slot_add(self):
"Test index page with login at /projects/task/view/time/<task_id>add/"
response = self.client.post('/accounts/login',
{'username': self.username, 'password': self.password })
self.assertRedirects(response, '/')
response = self.client.get(reverse('projects_task_time_slot_add', args=[self.task.id]))
self.assertEquals(response.status_code, 200)
def test_time_slot_view_login(self):
"Test index page with login at /projects/task/view/time/<time_slot_id>"
response = self.client.post('/accounts/login',
{'username': self.username, 'password': self.password })
self.assertRedirects(response, '/')
response = self.client.get(reverse('projects_task_view', args=[self.task.id]))
self.assertEquals(response.status_code, 200)
def test_time_slot_edit_login(self):
"Test index page with login at /projects/task/edit/time/<time_slot_id>"
response = self.client.post('/accounts/login',
{'username': self.username, 'password': self.password })
self.assertRedirects(response, '/')
response = self.client.get(reverse('projects_task_edit', args=[self.task.id]))
self.assertEquals(response.status_code, 200)
def test_time_slot_delete_login(self):
"Test index page with login at /projects/task/delete/time/<time_slot_id>"
response = self.client.post('/accounts/login',
{'username': self.username, 'password': self.password })
self.assertRedirects(response, '/')
response = self.client.get(reverse('projects_task_delete', args=[self.task.id]))
self.assertEquals(response.status_code, 200)
# Task Statuses
def test_task_status_add(self):
"Test index page with login at /projects/task/status/add/"
response = self.client.post('/accounts/login',
{'username': self.username, 'password': self.password })
self.assertRedirects(response, '/')
response = self.client.get(reverse('projects_task_status_add'))
self.assertEquals(response.status_code, 200)
def test_task_status_view_login(self):
"Test index page with login at /projects/task/status/view/<status_id>/"
response = self.client.post('/accounts/login',
{'username': self.username, 'password': self.password })
self.assertRedirects(response, '/')
response = self.client.get(reverse('projects_index_by_status', args=[self.status.id]))
self.assertEquals(response.status_code, 200)
def test_task_status_edit_login(self):
"Test index page with login at /projects/task/status/edit/<status_id>/"
response = self.client.post('/accounts/login',
{'username': self.username, 'password': self.password })
self.assertRedirects(response, '/')
response = self.client.get(reverse('projects_task_status_edit', args=[self.status.id]))
self.assertEquals(response.status_code, 200)
def test_task_status_delete_login(self):
"Test index page with login at /projects/task/status/delete/<status_id>/"
response = self.client.post('/accounts/login',
{'username': self.username, 'password': self.password })
self.assertRedirects(response, '/')
response = self.client.get(reverse('projects_task_status_delete', args=[self.status.id]))
self.assertEquals(response.status_code, 200)
# Settings
def test_project_settings_view(self):
"Test index page with login at /projects/settings/view/"
response = self.client.post('/accounts/login',
{'username': self.username, 'password': self.password })
self.assertRedirects(response, '/')
response = self.client.get(reverse('projects_settings_view'))
self.assertEquals(response.status_code, 200)
def test_project_settings_edit(self):
"Test index page with login at /projects/settings/edit/"
response = self.client.post('/accounts/login',
{'username': self.username, 'password': self.password })
self.assertRedirects(response, '/')
response = self.client.get(reverse('projects_settings_edit'))
self.assertEquals(response.status_code, 200)
######################################
# Testing views when user is not logged in
######################################
def test_index(self):
"Test index page at /projects/"
response = self.client.get('/projects/')
# Redirects as unauthenticated
self.assertRedirects(response, reverse('user_login'))
# Projects
def test_project_add_out(self):
"Testing /projects/add/"
response = self.client.get(reverse('project_add'))
self.assertRedirects(response, reverse('user_login'))
def test_project_add_typed_out(self):
"Testing /projects/add/<project_id>/"
response = self.client.get(reverse('projects_project_add_typed', args=[self.parent.id]))
self.assertRedirects(response, reverse('user_login'))
def test_project_view_out(self):
"Testing /projects/view/<project_id>"
response = self.client.get(reverse('projects_project_view', args=[self.project.id]))
self.assertRedirects(response, reverse('user_login'))
def test_project_edit_out(self):
"Testing /projects/edit//<project_id>"
response = self.client.get(reverse('projects_project_edit', args=[self.project.id]))
self.assertRedirects(response, reverse('user_login'))
def test_project_delete_out(self):
"Testing /projects/delete//<project_id>"
response = self.client.get(reverse('projects_project_delete', args=[self.project.id]))
self.assertRedirects(response, reverse('user_login'))
# Milestones
def test_milestone_add_out(self):
"Testing /projects/milestone/add"
response = self.client.get(reverse('projects_milestone_add'))
self.assertRedirects(response, reverse('user_login'))
def test_milestone_add_typed_out(self):
"Testing /projects/milestone/add/<project_id>"
response = self.client.get(reverse('projects_milestone_add_typed', args=[self.parent.id]))
self.assertRedirects(response, reverse('user_login'))
def test_milestone_view_out(self):
"Testing /projects/milestone/view/<milestone_id>"
response = self.client.get(reverse('projects_milestone_view', args=[self.milestone.id]))
self.assertRedirects(response, reverse('user_login'))
def test_milestone_edit_out(self):
"Testing /projects/milestone/edit/<milestone_id>"
response = self.client.get(reverse('projects_milestone_edit', args=[self.milestone.id]))
self.assertRedirects(response, reverse('user_login'))
def test_milestone_delete_out(self):
"Testing /projects/milestone/delete/<milestone_id>"
response = self.client.get(reverse('projects_milestone_delete', args=[self.milestone.id]))
self.assertRedirects(response, reverse('user_login'))
# Tasks
def test_task_add_out(self):
"Testing /projects/task/add/"
response = self.client.get(reverse('projects_task_add'))
self.assertRedirects(response, reverse('user_login'))
def test_task_add_typed_out(self):
"Testing /projects/task/add/<project_id>"
response = self.client.get(reverse('projects_task_add_typed', args=[self.project.id]))
self.assertRedirects(response, reverse('user_login'))
def test_task_add_to_milestone_out(self):
"Testing /projects/task/add/<milestone_id>"
response = self.client.get(reverse('projects_task_add_to_milestone', args=[self.milestone.id]))
self.assertRedirects(response, reverse('user_login'))
def test_task_add_subtask_out(self):
"Testing /projects/task/add/<task_id>/"
response = self.client.get(reverse('projects_task_add_subtask', args=[self.parent_task.id]))
self.assertRedirects(response, reverse('user_login'))
def test_task_set_status_out(self):
"Testing /projects/task/add/<task_id>/status/<status_id>"
response = self.client.get(reverse('projects_task_set_status', args=[self.task.id, self.status.id]))
self.assertRedirects(response, reverse('user_login'))
def test_task_view_out(self):
"Testing /projects/task/view/<task_id>"
response = self.client.get(reverse('projects_task_view', args=[self.task.id]))
self.assertRedirects(response, reverse('user_login'))
def test_task_edit_out(self):
"Testing /projects/task/edit/<task_id>"
response = self.client.get(reverse('projects_task_edit', args=[self.task.id]))
self.assertRedirects(response, reverse('user_login'))
def test_task_delete_out(self):
"Testing /projects/task/delete/<task_id>"
response = self.client.get(reverse('projects_task_delete', args=[self.task.id]))
self.assertRedirects(response, reverse('user_login'))
# Task Time Slots
def test_time_slot_add_out(self):
"Testing /projects/task/view/time/<task_id>add/"
response = self.client.get(reverse('projects_task_time_slot_add', args=[self.task.id]))
self.assertRedirects(response, reverse('user_login'))
def test_time_slot_view_out(self):
"Testing /projects/task/view/time/<time_slot_id>"
response = self.client.get(reverse('projects_task_view', args=[self.task.id]))
self.assertRedirects(response, reverse('user_login'))
def test_time_slot_edit_out(self):
"Testing /projects/task/edit/time/<time_slot_id>"
response = self.client.get(reverse('projects_task_edit', args=[self.task.id]))
self.assertRedirects(response, reverse('user_login'))
def test_time_slot_delete_out(self):
"Testing /projects/task/delete/time/<time_slot_id>"
response = self.client.get(reverse('projects_task_delete', args=[self.task.id]))
self.assertRedirects(response, reverse('user_login'))
# Task Statuses
def test_task_status_add_out(self):
"Testing /projects/task/status/add/"
response = self.client.get(reverse('projects_task_status_add'))
self.assertRedirects(response, reverse('user_login'))
def test_task_status_view_out(self):
"Testing /projects/task/status/view/<status_id>/"
response = self.client.get(reverse('projects_index_by_status', args=[self.status.id]))
self.assertRedirects(response, reverse('user_login'))
def test_task_status_edit_out(self):
"Testing /projects/task/status/edit/<status_id>/"
response = self.client.get(reverse('projects_task_status_edit', args=[self.status.id]))
self.assertRedirects(response, reverse('user_login'))
def test_task_status_delete_out(self):
"Testing /projects/task/status/delete/<status_id>/"
response = self.client.get(reverse('projects_task_status_delete', args=[self.status.id]))
self.assertRedirects(response, reverse('user_login'))
# Settings
def test_project_settings_view_out(self):
"Testing /projects/settings/view/"
response = self.client.get(reverse('projects_settings_view'))
self.assertRedirects(response, reverse('user_login'))
def test_project_settings_edit_out(self):
"Testing /projects/settings/edit/"
response = self.client.get(reverse('projects_settings_edit'))
self.assertRedirects(response, reverse('user_login'))
class NewsViewsTest(TestCase):
"Finance functional tests for views"
username = "******"
password = "******"
prepared = False
def setUp(self):
"Initial Setup"
if not self.prepared:
# Clean up first
Object.objects.all().delete()
User.objects.all().delete()
# Create objects
try:
self.group = Group.objects.get(name='test')
except Group.DoesNotExist:
Group.objects.all().delete()
self.group = Group(name='test')
self.group.save()
try:
self.user = DjangoUser.objects.get(username=self.username)
self.user.set_password(self.password)
try:
self.profile = self.user.get_profile()
except Exception:
User.objects.all().delete()
self.user = DjangoUser(username=self.username, password='')
self.user.set_password(self.password)
self.user.save()
except DjangoUser.DoesNotExist:
User.objects.all().delete()
self.user = DjangoUser(username=self.username, password='')
self.user.set_password(self.password)
self.user.save()
try:
perspective = Perspective.objects.get(name='default')
except Perspective.DoesNotExist:
Perspective.objects.all().delete()
perspective = Perspective(name='default')
perspective.set_default_user()
perspective.save()
ModuleSetting.set('default_perspective', perspective.id)
self.client = Client()
self.prepared = True
######################################
# Testing views when user is logged in
######################################
def test_news_index_login(self):
"Test index page with login at /news/all/"
response = self.client.post('/accounts/login', {
'username': self.username,
'password': self.password
})
self.assertRedirects(response, '/')
response = self.client.get(reverse('news_index'))
self.assertEquals(response.status_code, 200)
def test_news_top(self):
"Test index page with login at /news/top/"
response = self.client.post('/accounts/login', {
'username': self.username,
'password': self.password
})
self.assertRedirects(response, '/')
response = self.client.get(reverse('news_top'))
self.assertEquals(response.status_code, 200)
def test_news_my_activity(self):
"Test index page with login at /news/my/"
response = self.client.post('/accounts/login', {
'username': self.username,
'password': self.password
})
self.assertRedirects(response, '/')
response = self.client.get(reverse('news_my_activity'))
self.assertEquals(response.status_code, 200)
def test_news_watchlist(self):
"Test index page with login at /news/watchlist/"
response = self.client.post('/accounts/login', {
'username': self.username,
'password': self.password
})
self.assertRedirects(response, '/')
response = self.client.get(reverse('news_my_watchlist'))
self.assertEquals(response.status_code, 200)
######################################
# Testing views when user is not logged in
######################################
def test_news_index(self):
"Testing /news/"
response = self.client.get(reverse('news'))
# Redirects as unauthenticated
self.assertRedirects(response, "/accounts/login")
def test_news_top_out(self):
"Testing /news/top/"
response = self.client.get(reverse('news_top'))
self.assertRedirects(response, reverse('user_login'))
def test_news_my_activity_out(self):
"Testing /news/my/"
response = self.client.get(reverse('news_my_activity'))
self.assertRedirects(response, reverse('user_login'))
def test_news_watchlist_out(self):
"Testing /news/watchlist/"
response = self.client.get(reverse('news_my_watchlist'))
self.assertRedirects(response, reverse('user_login'))
class NewsViewsTest(TestCase):
"Finance functional tests for views"
username = "******"
password = "******"
prepared = False
def setUp(self):
"Initial Setup"
if not self.prepared:
# Clean up first
Object.objects.all().delete()
User.objects.all().delete()
# Create objects
try:
self.group = Group.objects.get(name='test')
except Group.DoesNotExist:
Group.objects.all().delete()
self.group = Group(name='test')
self.group.save()
try:
self.user = DjangoUser.objects.get(username=self.username)
self.user.set_password(self.password)
try:
self.profile = self.user.get_profile()
except Exception:
User.objects.all().delete()
self.user = DjangoUser(username=self.username, password='')
self.user.set_password(self.password)
self.user.save()
except DjangoUser.DoesNotExist:
User.objects.all().delete()
self.user = DjangoUser(username=self.username, password='')
self.user.set_password(self.password)
self.user.save()
try:
perspective = Perspective.objects.get(name='default')
except Perspective.DoesNotExist:
Perspective.objects.all().delete()
perspective = Perspective(name='default')
perspective.set_default_user()
perspective.save()
ModuleSetting.set('default_perspective', perspective.id)
self.client = Client()
self.prepared = True
######################################
# Testing views when user is logged in
######################################
def test_news_index_login(self):
"Test index page with login at /news/all/"
response = self.client.post('/accounts/login',
{'username': self.username, 'password': self.password })
self.assertRedirects(response, '/')
response = self.client.get(reverse('news_index'))
self.assertEquals(response.status_code, 200)
def test_news_top(self):
"Test index page with login at /news/top/"
response = self.client.post('/accounts/login',
{'username': self.username, 'password': self.password })
self.assertRedirects(response, '/')
response = self.client.get(reverse('news_top'))
self.assertEquals(response.status_code, 200)
def test_news_my_activity(self):
"Test index page with login at /news/my/"
response = self.client.post('/accounts/login',
{'username': self.username, 'password': self.password })
self.assertRedirects(response, '/')
response = self.client.get(reverse('news_my_activity'))
self.assertEquals(response.status_code, 200)
def test_news_watchlist(self):
"Test index page with login at /news/watchlist/"
response = self.client.post('/accounts/login',
{'username': self.username, 'password': self.password })
self.assertRedirects(response, '/')
response = self.client.get(reverse('news_my_watchlist'))
self.assertEquals(response.status_code, 200)
######################################
# Testing views when user is not logged in
######################################
def test_news_index(self):
"Testing /news/"
response = self.client.get(reverse('news'))
# Redirects as unauthenticated
self.assertRedirects(response, "/accounts/login")
def test_news_top_out(self):
"Testing /news/top/"
response = self.client.get(reverse('news_top'))
self.assertRedirects(response, reverse('user_login'))
def test_news_my_activity_out(self):
"Testing /news/my/"
response = self.client.get(reverse('news_my_activity'))
self.assertRedirects(response, reverse('user_login'))
def test_news_watchlist_out(self):
"Testing /news/watchlist/"
response = self.client.get(reverse('news_my_watchlist'))
self.assertRedirects(response, reverse('user_login'))
class CoreViewsTest(TestCase):
"Core View tests"
username = "******"
password = "******"
prepared = False
def setUp(self):
"Initial Setup"
if not self.prepared:
Object.objects.all().delete()
# Create objects
try:
self.group = Group.objects.get(name='test')
except Group.DoesNotExist:
Group.objects.all().delete()
self.group = Group(name='test')
self.group.save()
try:
self.user = DjangoUser.objects.get(username=self.username)
self.user.set_password(self.password)
try:
self.profile = self.user.get_profile()
except Exception:
User.objects.all().delete()
self.user = DjangoUser(username=self.username, password='')
self.user.set_password(self.password)
self.user.save()
except DjangoUser.DoesNotExist:
User.objects.all().delete()
self.user = DjangoUser(username=self.username, password='')
self.user.set_password(self.password)
self.user.save()
try:
perspective = Perspective.objects.get(name='default')
except Perspective.DoesNotExist:
Perspective.objects.all().delete()
perspective = Perspective(name='default')
perspective.set_default_user()
perspective.save()
ModuleSetting.set('default_perspective', perspective.id)
self.perspective = Perspective(name='test')
self.perspective.set_default_user()
self.perspective.save()
self.group = Group(name='test')
self.group.save()
self.client = Client()
self.prepared = True
######################################
# Testing views when user is logged in
######################################
def test_home_login(self):
"Test home page with login at /"
response = self.client.post('/accounts/login', {'username': self.username,
'password': self.password })
self.assertRedirects(response, '/')
response = self.client.get('/')
self.assertEquals(response.status_code, 200)
# Perspectives
def test_index_perspectives_login(self):
"Test page with login at /admin/perspectives/"
response = self.client.post('/accounts/login', {'username': self.username,
'password': self.password })
self.assertRedirects(response, '/')
response = self.client.get(reverse('core_admin_index_perspectives'))
self.assertEquals(response.status_code, 200)
def test_perspective_add(self):
"Test index page with login at /admin/perspective/add"
response = self.client.post('/accounts/login',
{'username': self.username, 'password': self.password })
self.assertRedirects(response, '/')
response = self.client.get(reverse('core_admin_perspective_add'))
self.assertEquals(response.status_code, 200)
def test_perspective_view(self):
"Test index page with login at /admin/perspective/view/<perspective_id>"
response = self.client.post('/accounts/login',
{'username': self.username, 'password': self.password })
self.assertRedirects(response, '/')
response = self.client.get(reverse('core_admin_perspective_view', args=[self.perspective.id]))
self.assertEquals(response.status_code, 200)
def test_perspective_edit(self):
"Test index page with login at /admin/perspective/edit/<perspective_id>"
response = self.client.post('/accounts/login',
{'username': self.username, 'password': self.password })
self.assertRedirects(response, '/')
response = self.client.get(reverse('core_admin_perspective_edit', args=[self.perspective.id]))
self.assertEquals(response.status_code, 200)
def test_perspective_delete(self):
"Test index page with login at /admin/perspective/delete/<perspective_id>"
response = self.client.post('/accounts/login',
{'username': self.username, 'password': self.password })
self.assertRedirects(response, '/')
response = self.client.get(reverse('core_admin_perspective_delete', args=[self.perspective.id]))
self.assertEquals(response.status_code, 200)
# Modules
def test_index_modules_login(self):
"Test page with login at /admin/modules/"
response = self.client.post('/accounts/login', {'username': self.username,
'password': self.password })
self.assertRedirects(response, '/')
response = self.client.get(reverse('core_admin_index_modules'))
self.assertEquals(response.status_code, 200)
# Users
def test_index_users_login(self):
"Test page with login at /admin/users/"
response = self.client.post('/accounts/login', {'username': self.username,
'password': self.password })
self.assertRedirects(response, '/')
response = self.client.get(reverse('core_admin_index_users'))
self.assertEquals(response.status_code, 200)
def test_core_user_add(self):
"Test page with login at /admin/user/add"
response = self.client.post('/accounts/login', {'username': self.username,
'password': self.password })
self.assertRedirects(response, '/')
response = self.client.get(reverse('core_admin_user_add'))
self.assertEquals(response.status_code, 200)
def test_core_user_invite(self):
"Test page with login at /admin/user/invite"
response = self.client.post('/accounts/login', {'username': self.username,
'password': self.password })
self.assertRedirects(response, '/')
response = self.client.get(reverse('core_admin_user_invite'))
self.assertEquals(response.status_code, 200)
# Groups
def test_index_groups_login(self):
"Test page with login at /admin/groups/"
response = self.client.post('/accounts/login', {'username': self.username,
'password': self.password })
self.assertRedirects(response, '/')
response = self.client.get(reverse('core_admin_index_groups'))
self.assertEquals(response.status_code, 200)
def test_core_group_add(self):
"Test page with login at /admin/group/add"
response = self.client.post('/accounts/login', {'username': self.username,
'password': self.password })
self.assertRedirects(response, '/')
response = self.client.get(reverse('core_admin_group_add'))
self.assertEquals(response.status_code, 200)
def test_core_group_view(self):
"Test index page with login at /admin/group/view/<group_id>"
response = self.client.post('/accounts/login',
{'username': self.username, 'password': self.password })
self.assertRedirects(response, '/')
response = self.client.get(reverse('core_admin_group_view', args=[self.group.id]))
self.assertEquals(response.status_code, 200)
def test_core_group_edit(self):
"Test index page with login at /admin/group/edit/<group_id>"
response = self.client.post('/accounts/login',
{'username': self.username, 'password': self.password })
self.assertRedirects(response, '/')
response = self.client.get(reverse('core_admin_group_edit', args=[self.group.id]))
self.assertEquals(response.status_code, 200)
def test_core_group_delete(self):
"Test index page with login at /admin/group/delete/<group_id>"
response = self.client.post('/accounts/login',
{'username': self.username, 'password': self.password })
self.assertRedirects(response, '/')
response = self.client.get(reverse('core_admin_group_delete', args=[self.group.id]))
self.assertEquals(response.status_code, 200)
# Settings
def test_core_settings_view(self):
"Test index page with login at /admin/settings/view/"
response = self.client.post('/accounts/login',
{'username': self.username, 'password': self.password })
self.assertRedirects(response, '/')
response = self.client.get(reverse('core_settings_view'))
self.assertEquals(response.status_code, 200)
def test_core_settings_edit(self):
"Test index page with login at /admin/settings/edit/"
response = self.client.post('/accounts/login',
{'username': self.username, 'password': self.password })
self.assertRedirects(response, '/')
response = self.client.get(reverse('core_settings_edit'))
self.assertEquals(response.status_code, 200)
######################################
# Testing views when user is not logged in
######################################
def test_home(self):
"Test home page at /"
response = self.client.get('/')
# Redirects as unauthenticated
self.assertRedirects(response, reverse('user_login'))
def test_index_perspectives_out(self):
"Test page at /admin/perspectives/"
response = self.client.get(reverse('core_admin_index_perspectives'))
self.assertRedirects(response, reverse('user_login'))
def test_perspective_add_out(self):
"Test add perspective page at /admin/perspective/add"
response = self.client.get(reverse('core_admin_perspective_add'))
self.assertRedirects(response, reverse('user_login'))
def test_perspective_view_out(self):
"Test perspective view at /admin/perspective/view/<perspective_id>"
response = self.client.get(reverse('core_admin_perspective_view', args=[self.perspective.id]))
self.assertRedirects(response, reverse('user_login'))
def test_perspective_edit_out(self):
"Test perspective add at /admin/perspective/edit/<perspective_id>"
response = self.client.get(reverse('core_admin_perspective_edit', args=[self.perspective.id]))
self.assertRedirects(response, reverse('user_login'))
def test_perspective_delete_out(self):
"Test perspective delete at /admin/perspective/delete/<perspective_id>"
response = self.client.get(reverse('core_admin_perspective_delete', args=[self.perspective.id]))
self.assertRedirects(response, reverse('user_login'))
# Modules
def test_index_modules_out(self):
"Test index modules page at /admin/modules/"
response = self.client.get(reverse('core_admin_index_modules'))
self.assertRedirects(response, reverse('user_login'))
# Users
def test_index_users_out(self):
"Test index users page at /admin/users/"
response = self.client.get(reverse('core_admin_index_users'))
self.assertRedirects(response, reverse('user_login'))
def test_core_user_add_out(self):
"Test user add at /admin/user/add"
response = self.client.get(reverse('core_admin_user_add'))
self.assertRedirects(response, reverse('user_login'))
def test_core_user_invite_out(self):
"Test user invite at /admin/user/invite"
response = self.client.get(reverse('core_admin_user_invite'))
self.assertRedirects(response, reverse('user_login'))
# Groups
def test_index_groups_out(self):
"Test index groups at /admin/groups/"
response = self.client.get(reverse('core_admin_index_groups'))
self.assertRedirects(response, reverse('user_login'))
def test_core_group_add_out(self):
"Test group add at /admin/group/add"
response = self.client.get(reverse('core_admin_group_add'))
self.assertRedirects(response, reverse('user_login'))
def test_core_group_view_out(self):
"Test group view at /admin/group/view/<group_id>"
response = self.client.get(reverse('core_admin_group_view', args=[self.group.id]))
self.assertRedirects(response, reverse('user_login'))
def test_core_group_edit_out(self):
"Test group edit at /admin/group/edit/<group_id>"
response = self.client.get(reverse('core_admin_group_edit', args=[self.group.id]))
self.assertRedirects(response, reverse('user_login'))
def test_core_group_delete_out(self):
"Test group delete at /admin/group/delete/<group_id>"
response = self.client.get(reverse('core_admin_group_delete', args=[self.group.id]))
self.assertRedirects(response, reverse('user_login'))
# Settings
def test_core_settings_view_out(self):
"Test isettings view at /admin/settings/view/"
response = self.client.get(reverse('core_settings_view'))
self.assertRedirects(response, reverse('user_login'))
def test_core_settings_edit_out(self):
"Test settings edit at /admin/settings/edit/"
response = self.client.get(reverse('core_settings_edit'))
self.assertRedirects(response, reverse('user_login'))
class ProjectsAPITest(TestCase):
"Projects functional tests for api"
username = "******"
password = "******"
prepared = False
authentication_headers = {"CONTENT_TYPE": "application/json",
"HTTP_AUTHORIZATION": "Basic YXBpX3Rlc3Q6YXBpX3Bhc3N3b3Jk"}
content_type = 'application/json'
def setUp(self):
"Initial Setup"
if not self.prepared:
# Clean up first
Object.objects.all().delete()
User.objects.all().delete()
# Create objects
try:
self.group = Group.objects.get(name='api_test')
except Group.DoesNotExist:
Group.objects.all().delete()
self.group = Group(name='api_test')
self.group.save()
try:
self.user = DjangoUser.objects.get(username=self.username)
self.user.set_password(self.password)
try:
self.profile = self.user.get_profile()
except Exception:
User.objects.all().delete()
self.user = DjangoUser(username=self.username, password='')
self.user.set_password(self.password)
self.user.save()
except DjangoUser.DoesNotExist:
User.objects.all().delete()
self.user = DjangoUser(username=self.username, password='')
self.user.set_password(self.password)
self.user.save()
try:
perspective = Perspective.objects.get(name='default')
except Perspective.DoesNotExist:
Perspective.objects.all().delete()
perspective = Perspective(name='default')
perspective.set_default_user()
perspective.save()
ModuleSetting.set('default_perspective', perspective.id)
self.contact_type = ContactType(name='api_test')
self.contact_type.set_default_user()
self.contact_type.save()
self.contact = Contact(
name='api_test', contact_type=self.contact_type)
self.contact.set_default_user()
self.contact.save()
self.project = Project(
name='api_test', manager=self.contact, client=self.contact)
self.project.set_default_user()
self.project.save()
self.status = TaskStatus(name='api_test')
self.status.set_default_user()
self.status.save()
self.milestone = Milestone(
name='api_test', project=self.project, status=self.status)
self.milestone.set_default_user()
self.milestone.save()
self.task = Task(
name='api_test', project=self.project, status=self.status, priority=3)
self.task.set_default_user()
self.task.save()
self.time_slot = TaskTimeSlot(
task=self.task, details='api_test', time_from=datetime.now(), user=self.user.get_profile())
self.time_slot.set_default_user()
self.time_slot.save()
self.parent = Project(name='api_test')
self.parent.set_default_user()
self.parent.save()
self.parent_task = Task(
name='api_test', project=self.project, status=self.status, priority=3)
self.parent_task.set_default_user()
self.parent_task.save()
self.client = Client()
self.prepared = True
def test_unauthenticated_access(self):
"Test index page at /projects"
response = self.client.get('/api/projects/projects')
# Redirects as unauthenticated
self.assertEquals(response.status_code, 401)
# Get info about projects, milestones, status, tasks, tasktimes.
def test_get_project_list(self):
""" Test index page api/projects """
response = self.client.get(
path=reverse('api_projects'), **self.authentication_headers)
self.assertEquals(response.status_code, 200)
def test_get_status_list(self):
""" Test index page api/status """
response = self.client.get(
path=reverse('api_projects_status'), **self.authentication_headers)
self.assertEquals(response.status_code, 200)
def test_get_milestones_list(self):
""" Test index page api/milestones """
response = self.client.get(
path=reverse('api_projects_milestones'), **self.authentication_headers)
self.assertEquals(response.status_code, 200)
def test_get_task_list(self):
""" Test index page api/tasks """
response = self.client.get(
path=reverse('api_projects_tasks'), **self.authentication_headers)
self.assertEquals(response.status_code, 200)
def test_get_tasktimes_list(self):
""" Test index page api/tasktimes """
response = self.client.get(
path=reverse('api_projects_tasktimes'), **self.authentication_headers)
self.assertEquals(response.status_code, 200)
def test_get_project(self):
response = self.client.get(reverse(
'api_projects', kwargs={'object_ptr': self.project.id}), **self.authentication_headers)
self.assertEquals(response.status_code, 200)
data = json.loads(response.content)
self.assertEquals(data['id'], self.project.id)
self.assertEquals(data['name'], self.project.name)
self.assertEquals(data['details'], self.project.details)
def test_get_status(self):
response = self.client.get(reverse('api_projects_status', kwargs={
'object_ptr': self.status.id}), **self.authentication_headers)
self.assertEquals(response.status_code, 200)
data = json.loads(response.content)
self.assertEquals(data['id'], self.status.id)
self.assertEquals(data['name'], self.status.name)
def test_get_milestone(self):
response = self.client.get(reverse('api_projects_milestones', kwargs={
'object_ptr': self.milestone.id}), **self.authentication_headers)
self.assertEquals(response.status_code, 200)
data = json.loads(response.content)
self.assertEquals(data['id'], self.milestone.id)
self.assertEquals(data['name'], self.milestone.name)
self.assertEquals(data['project']['id'], self.milestone.project.id)
self.assertEquals(data['status']['id'], self.milestone.status.id)
def test_get_task(self):
response = self.client.get(reverse('api_projects_tasks', kwargs={
'object_ptr': self.task.id}), **self.authentication_headers)
self.assertEquals(response.status_code, 200)
data = json.loads(response.content)
self.assertEquals(data['id'], self.task.id)
self.assertEquals(data['name'], self.task.name)
self.assertEquals(data['priority'], self.task.priority)
self.assertEquals(data['project']['id'], self.task.project.id)
self.assertEquals(data['status']['id'], self.task.status.id)
def test_get_timeslot(self):
response = self.client.get(reverse('api_projects_tasktimes', kwargs={
'object_ptr': self.time_slot.id}), **self.authentication_headers)
self.assertEquals(response.status_code, 200)
data = json.loads(response.content)
self.assertEquals(data['id'], self.time_slot.id)
self.assertEquals(data['task']['id'], self.time_slot.task.id)
# Common test
def test_common_project(self):
# create new project
new_project = {'name': 'api test',
'details': '<p>test details</p>'}
response = self.client.post(reverse('api_projects'), data=json.dumps(new_project),
content_type=self.content_type, **self.authentication_headers)
# print response.request
self.assertEquals(response.status_code, 200)
# check data in response
data = json.loads(response.content)
self.assertEquals(data['name'], new_project['name'])
self.assertEquals(data['details'], new_project['details'])
project_id = data['id']
# get info about new project
response = self.client.get(path=reverse(
'api_projects', kwargs={'object_ptr': project_id}), **self.authentication_headers)
self.assertEquals(response.status_code, 200)
# get statuses list
response = self.client.get(
path=reverse('api_projects_status'), **self.authentication_headers)
self.assertEquals(response.status_code, 200)
statuses = json.loads(response.content)
fstatus = statuses[0]['id']
# create new task status
new_status = {'name': 'Open api test',
'active': True,
'hidden': False,
'details': '<p>test details</p>'}
response = self.client.post(reverse('api_projects_status'), data=json.dumps(new_status),
content_type=self.content_type, **self.authentication_headers)
self.assertEquals(response.status_code, 200)
data = json.loads(response.content)
self.assertEquals(data['name'], new_status['name'])
self.assertEquals(data['active'], new_status['active'])
self.assertEquals(data['hidden'], new_status['hidden'])
self.assertEquals(data['details'], new_status['details'])
sstatus = data['id']
# create new milestone
new_milestone = {'name': 'api test milestone',
'status': fstatus,
'project': project_id,
'start_date': '2011-06-09 12:00:00',
'details': '<p>test details</p>'}
response = self.client.post(reverse('api_projects_milestones'), data=json.dumps(new_milestone),
content_type=self.content_type, **self.authentication_headers)
self.assertEquals(response.status_code, 200)
data = json.loads(response.content)
self.assertEquals(data['name'], new_milestone['name'])
self.assertEquals(data['status']['id'], new_milestone['status'])
self.assertEquals(data['project']['id'], new_milestone['project'])
self.assertEquals(data['details'], new_milestone['details'])
milestone_id = data['id']
# create new task
new_task = {'name': 'api test task',
'status': sstatus,
'project': project_id,
'milestone': milestone_id,
'priority': 5,
'start_date': '2011-06-02 12:00:00',
'estimated_time': 5000,
'details': '<p>test details</p>'
}
response = self.client.post(reverse('api_projects_tasks'), data=json.dumps(new_task),
content_type=self.content_type, **self.authentication_headers)
self.assertEquals(response.status_code, 200)
data = json.loads(response.content)
self.assertEquals(data['name'], new_task['name'])
self.assertEquals(data['priority'], new_task['priority'])
self.assertEquals(data['status']['id'], new_task['status'])
self.assertEquals(data['project']['id'], new_task['project'])
self.assertEquals(data['milestone']['id'], new_task['milestone'])
self.assertEquals(data['estimated_time'], new_task['estimated_time'])
self.assertEquals(data['details'], new_task['details'])
task_id = data['id']
# create new subtask
new_sub_task = {'name': 'api test task',
'status': sstatus,
'parent': task_id,
'project': project_id,
'priority': 5,
'start_date': '2011-06-02 13:00:00',
'estimated_time': 2500,
'details': '<p>test details</p>'
}
response = self.client.post(reverse('api_projects_tasks'), data=json.dumps(new_sub_task),
content_type=self.content_type, **self.authentication_headers)
self.assertEquals(response.status_code, 200)
data = json.loads(response.content)
self.assertEquals(data['name'], new_sub_task['name'])
self.assertEquals(data['priority'], new_sub_task['priority'])
self.assertEquals(data['status']['id'], new_sub_task['status'])
self.assertEquals(data['parent']['id'], new_sub_task['parent'])
self.assertEquals(data['project']['id'], new_sub_task['project'])
self.assertEquals(
data['estimated_time'], new_sub_task['estimated_time'])
self.assertEquals(data['details'], new_sub_task['details'])
sub_task_id = data['id']
# create task time
new_tasktime = {'task': task_id,
'minutes': 400,
'details': '<p>test details</p>'
}
response = self.client.post(reverse('api_projects_tasktimes'), data=json.dumps(new_tasktime),
content_type=self.content_type, **self.authentication_headers)
self.assertEquals(response.status_code, 200)
data = json.loads(response.content)
self.assertEquals(data['task']['id'], new_tasktime['task'])
self.assertEquals(data['details'], new_tasktime['details'])
tasktime_id = data['id']
# start task time
response = self.client.get(path=reverse('api_projects_tasktime_start', kwargs={
'task_id': sub_task_id}), **self.authentication_headers)
self.assertEquals(response.status_code, 200)
data = json.loads(response.content)
slot_id = data['id']
sleep(60)
# stop task time
response = self.client.post(reverse('api_projects_tasktime_stop', kwargs={'slot_id': slot_id}), data=json.dumps({'details': '<p>test details</p>'}),
content_type=self.content_type, **self.authentication_headers)
self.assertEquals(response.status_code, 200)
# delete task time
response = self.client.delete(reverse('api_projects_tasktimes', kwargs={
'object_ptr': tasktime_id}), **self.authentication_headers)
self.assertEquals(response.status_code, 204)
# delete task
response = self.client.delete(reverse(
'api_projects_tasks', kwargs={'object_ptr': task_id}), **self.authentication_headers)
self.assertEquals(response.status_code, 204)
# check subtask
response = self.client.get(path=reverse('api_projects_tasks', kwargs={
'object_ptr': sub_task_id}), **self.authentication_headers)
self.assertEquals(response.status_code, 404)
# delete milestone
response = self.client.delete(reverse('api_projects_milestones', kwargs={
'object_ptr': milestone_id}), **self.authentication_headers)
self.assertEquals(response.status_code, 204)
# delete status
response = self.client.delete(reverse(
'api_projects_status', kwargs={'object_ptr': sstatus}), **self.authentication_headers)
self.assertEquals(response.status_code, 204)
# delete project
response = self.client.delete(reverse(
'api_projects', kwargs={'object_ptr': project_id}), **self.authentication_headers)
self.assertEquals(response.status_code, 204)
class ServicesViewsTest(TestCase):
"Services functional tests for api"
username = "******"
password = "******"
prepared = False
authentication_headers = {
"CONTENT_TYPE": "application/json",
"HTTP_AUTHORIZATION": "Basic YXBpX3Rlc3Q6YXBpX3Bhc3N3b3Jk"
}
content_type = 'application/json'
prepared = False
def setUp(self):
"Initial Setup"
if not self.prepared:
# Clean up first
Object.objects.all().delete()
User.objects.all().delete()
# Create objects
try:
self.group = Group.objects.get(name='test')
except Group.DoesNotExist:
Group.objects.all().delete()
self.group = Group(name='test')
self.group.save()
try:
self.user = DjangoUser.objects.get(username=self.username)
self.user.set_password(self.password)
try:
self.profile = self.user.get_profile()
except Exception:
User.objects.all().delete()
self.user = DjangoUser(username=self.username, password='')
self.user.set_password(self.password)
self.user.save()
except DjangoUser.DoesNotExist:
User.objects.all().delete()
self.user = DjangoUser(username=self.username, password='')
self.user.set_password(self.password)
self.user.save()
try:
perspective = Perspective.objects.get(name='default')
except Perspective.DoesNotExist:
Perspective.objects.all().delete()
perspective = Perspective(name='default')
perspective.set_user(self.user.get_profile())
perspective.save()
ModuleSetting.set('default_perspective', perspective.id)
self.contact_type = ContactType(name='test')
self.contact_type.set_default_user()
self.contact_type.save()
self.contact = Contact(name='test', contact_type=self.contact_type)
self.contact.set_default_user()
self.contact.save()
self.status = TicketStatus(name='TestStatus')
self.status.set_default_user()
self.status.save()
self.queue = TicketQueue(name='TestQueue',
default_ticket_status=self.status)
self.queue.set_default_user()
self.queue.save()
self.ticket = Ticket(name='TestTicket',
status=self.status,
queue=self.queue)
self.ticket.set_default_user()
self.ticket.save()
self.agent = ServiceAgent(related_user=self.user.get_profile(),
available_from=datetime.time(9),
available_to=datetime.time(17))
self.agent.set_default_user()
self.agent.save()
self.service = Service(name='test')
self.service.set_default_user()
self.service.save()
self.sla = ServiceLevelAgreement(name='test',
service=self.service,
client=self.contact,
provider=self.contact)
self.sla.set_default_user()
self.sla.save()
self.client = Client()
self.prepared = True
def test_unauthenticated_access(self):
"Test index page at /api/services/services"
response = self.client.get('/api/services/services')
# Redirects as unauthenticated
self.assertEquals(response.status_code, 401)
def test_get_ticket_statuses_list(self):
""" Test index page api/services/status """
response = self.client.get(path=reverse('api_services_status'),
**self.authentication_headers)
self.assertEquals(response.status_code, 200)
def test_get_status(self):
response = self.client.get(path=reverse(
'api_services_status', kwargs={'object_ptr': self.status.id}),
**self.authentication_headers)
self.assertEquals(response.status_code, 200)
def test_update_status(self):
updates = {'name': 'Api update', 'details': '<p>api details</p>'}
response = self.client.put(path=reverse(
'api_services_status', kwargs={'object_ptr': self.status.id}),
content_type=self.content_type,
data=json.dumps(updates),
**self.authentication_headers)
self.assertEquals(response.status_code, 200)
def test_get_services_list(self):
""" Test index page api/services """
response = self.client.get(path=reverse('api_services'),
**self.authentication_headers)
self.assertEquals(response.status_code, 200)
def test_get_service(self):
response = self.client.get(path=reverse(
'api_services', kwargs={'object_ptr': self.service.id}),
**self.authentication_headers)
self.assertEquals(response.status_code, 200)
def test_update_service(self):
updates = {'name': 'Api update', 'details': '<p>api details</p>'}
response = self.client.put(path=reverse(
'api_services', kwargs={'object_ptr': self.service.id}),
content_type=self.content_type,
data=json.dumps(updates),
**self.authentication_headers)
self.assertEquals(response.status_code, 200)
def test_get_sla_list(self):
""" Test index page api/services/sla """
response = self.client.get(path=reverse('api_services_sla'),
**self.authentication_headers)
self.assertEquals(response.status_code, 200)
def test_get_sla(self):
response = self.client.get(path=reverse(
'api_services_sla', kwargs={'object_ptr': self.sla.id}),
**self.authentication_headers)
self.assertEquals(response.status_code, 200)
def test_update_sla(self):
updates = {
'name': 'Api update',
'service': self.service.id,
'provider': self.contact.id
}
response = self.client.put(path=reverse(
'api_services_sla', kwargs={'object_ptr': self.sla.id}),
content_type=self.content_type,
data=json.dumps(updates),
**self.authentication_headers)
print 'content:'
print response.content
self.assertEquals(response.status_code, 200)
def test_get_agents_list(self):
""" Test index page api/services/agents """
response = self.client.get(path=reverse('api_services_agents'),
**self.authentication_headers)
self.assertEquals(response.status_code, 200)
def test_get_agent(self):
response = self.client.get(path=reverse(
'api_services_agents', kwargs={'object_ptr': self.agent.id}),
**self.authentication_headers)
self.assertEquals(response.status_code, 200)
def test_update_sla(self):
updates = {"activate": True, "related_user": User.objects.all()[0].id}
response = self.client.put(path=reverse(
'api_services_agents', kwargs={'object_ptr': self.agent.id}),
content_type=self.content_type,
data=json.dumps(updates),
**self.authentication_headers)
self.assertEquals(response.status_code, 200)
def test_get_queues_list(self):
""" Test index page api/services/queues """
response = self.client.get(path=reverse('api_services_queues'),
**self.authentication_headers)
self.assertEquals(response.status_code, 200)
def test_get_queue(self):
response = self.client.get(path=reverse(
'api_services_queues', kwargs={'object_ptr': self.queue.id}),
**self.authentication_headers)
self.assertEquals(response.status_code, 200)
def test_update_queue(self):
updates = {
"name": "Api test",
"default_ticket_priority": 5,
"ticket_code": "api",
"waiting_time": 300,
"default_ticket_status": self.status.id
}
response = self.client.put(path=reverse(
'api_services_queues', kwargs={'object_ptr': self.queue.id}),
content_type=self.content_type,
data=json.dumps(updates),
**self.authentication_headers)
self.assertEquals(response.status_code, 200)
def test_get_records(self):
""" Test index page api/services/ticket/records/{ticket number} """
response = self.client.get(path=reverse(
'api_services_ticket_records',
kwargs={'ticket_id': self.ticket.id}),
**self.authentication_headers)
self.assertEquals(response.status_code, 200)
def test_create_record(self):
new_record = {"body": "api test message", "notify": False}
response = self.client.post(path=reverse(
'api_services_ticket_records',
kwargs={'ticket_id': self.ticket.id}),
data=json.dumps(new_record),
content_type=self.content_type,
**self.authentication_headers)
self.assertEquals(response.status_code, 200)
data = json.loads(response.content)
self.assertEquals(new_record['body'], data['body'])
def test_get_tasks_list(self):
""" Test index page api/services/tasks """
response = self.client.get(path=reverse('api_services_tickets'),
**self.authentication_headers)
self.assertEquals(response.status_code, 200)
def test_get_ticket(self):
response = self.client.get(path=reverse(
'api_services_tickets', kwargs={'object_ptr': self.ticket.id}),
**self.authentication_headers)
self.assertEquals(response.status_code, 200)
def test_update_ticket(self):
updates = {
"name": "Api updates",
"status": self.status.id,
"priority": 3,
"urgency": 5
}
response = self.client.put(path=reverse(
'api_services_tickets', kwargs={'object_ptr': self.ticket.id}),
content_type=self.content_type,
data=json.dumps(updates),
**self.authentication_headers)
self.assertEquals(response.status_code, 200)
def test_create_ticket(self):
new_ticket = {
"name": "Api creates",
"status": self.status.id,
"priority": 3,
"urgency": 5
}
response = self.client.post(
path=reverse('api_services_tickets', ) + '?' +
urllib.urlencode({'queue_id': self.queue.id}),
content_type=self.content_type,
data=json.dumps(new_ticket),
**self.authentication_headers)
self.assertEquals(response.status_code, 200)
data = json.loads(response.content)
self.assertEquals(new_ticket["name"], data["name"])
self.assertEquals(new_ticket["urgency"], data["urgency"])
self.assertEquals(new_ticket["priority"], data["priority"])
self.assertEquals(new_ticket["status"], data["status"]["id"])
class InfrastructureApiTest(TestCase):
"Infrastructure functional tests for api"
username = "******"
password = "******"
prepared = False
authentication_headers = {"CONTENT_TYPE": "application/json",
"HTTP_AUTHORIZATION": "Basic YXBpX3Rlc3Q6YXBpX3Bhc3N3b3Jk"}
content_type = 'application/json'
def setUp(self):
"Initial Setup"
if not self.prepared:
# Clean up first
Object.objects.all().delete()
# Create objects
try:
self.group = Group.objects.get(name='test')
except Group.DoesNotExist:
Group.objects.all().delete()
self.group = Group(name='test')
self.group.save()
try:
self.user = DjangoUser.objects.get(username=self.username)
self.user.set_password(self.password)
try:
self.profile = self.user.get_profile()
except Exception:
User.objects.all().delete()
self.user = DjangoUser(username=self.username, password='')
self.user.set_password(self.password)
self.user.save()
except DjangoUser.DoesNotExist:
User.objects.all().delete()
self.user = DjangoUser(username=self.username, password='')
self.user.set_password(self.password)
self.user.save()
try:
perspective = Perspective.objects.get(name='default')
except Perspective.DoesNotExist:
Perspective.objects.all().delete()
perspective = Perspective(name='default')
perspective.set_default_user()
perspective.save()
ModuleSetting.set('default_perspective', perspective.id)
self.field = ItemField(
name='test', label='test', field_type='text')
self.field.set_default_user()
self.field.save()
self.type = ItemType(name='test')
self.type.set_default_user()
self.type.save()
self.type.fields.add(self.field)
self.status = ItemStatus(name='test')
self.status.set_default_user()
self.status.save()
self.item = Item(
name='test', item_type=self.type, status=self.status)
self.item.set_default_user()
self.item.save()
self.value = ItemValue(field=self.field, item=self.item)
self.value.save()
self.servicing = ItemServicing(name='test')
self.servicing.set_default_user()
self.servicing.save()
self.client = Client()
self.prepared = True
def test_unauthenticated_access(self):
"Test index page at /api/infrastructure/types"
response = self.client.get('/api/infrastructure/types')
# Redirects as unauthenticated
self.assertEquals(response.status_code, 401)
def test_get_fields_list(self):
""" Test index page api/infrastructure/types """
response = self.client.get(
path=reverse('api_infrastructure_fields'), **self.authentication_headers)
self.assertEquals(response.status_code, 200)
def test_get_field(self):
response = self.client.get(path=reverse('api_infrastructure_fields', kwargs={
'object_ptr': self.field.id}), **self.authentication_headers)
self.assertEquals(response.status_code, 200)
def test_update_field(self):
updates = {"name": "Api_name", "label": "Api label", "field_type": "text",
"required": True, "details": "Api details"}
response = self.client.put(path=reverse('api_infrastructure_fields', kwargs={'object_ptr': self.field.id}),
content_type=self.content_type, data=json.dumps(updates), **self.authentication_headers)
self.assertEquals(response.status_code, 200)
data = json.loads(response.content)
self.assertEquals(data['name'], updates['name'])
self.assertEquals(data['label'], updates['label'])
self.assertEquals(data['field_type'], updates['field_type'])
self.assertEquals(data['required'], updates['required'])
self.assertEquals(data['details'], updates['details'])
def test_get_types_list(self):
""" Test index page api/infrastructure/types """
response = self.client.get(
path=reverse('api_infrastructure_types'), **self.authentication_headers)
self.assertEquals(response.status_code, 200)
def test_get_type(self):
response = self.client.get(path=reverse('api_infrastructure_types', kwargs={
'object_ptr': self.type.id}), **self.authentication_headers)
self.assertEquals(response.status_code, 200)
def test_update_type(self):
updates = {"name": "Api type", "parent": None,
"details": "api test details", "fields": [self.field.id]}
response = self.client.put(path=reverse('api_infrastructure_types', kwargs={'object_ptr': self.type.id}),
content_type=self.content_type, data=json.dumps(updates), **self.authentication_headers)
self.assertEquals(response.status_code, 200)
data = json.loads(response.content)
self.assertEquals(data['name'], updates['name'])
self.assertIsNone(data['parent'])
self.assertEquals(data['details'], updates['details'])
for i, field in enumerate(data['fields']):
self.assertEquals(field['id'], updates['fields'][i])
def test_get_statuses_list(self):
""" Test index page api/infrastructure/types """
response = self.client.get(
path=reverse('api_infrastructure_statuses'), **self.authentication_headers)
self.assertEquals(response.status_code, 200)
def test_get_status(self):
response = self.client.get(path=reverse('api_infrastructure_statuses', kwargs={
'object_ptr': self.status.id}), **self.authentication_headers)
self.assertEquals(response.status_code, 200)
def test_update_status(self):
updates = {"name": "Api type", "active": True,
"hidden": False, "details": "Api details"}
response = self.client.put(path=reverse('api_infrastructure_statuses', kwargs={'object_ptr': self.status.id}),
content_type=self.content_type, data=json.dumps(updates), **self.authentication_headers)
self.assertEquals(response.status_code, 200)
data = json.loads(response.content)
self.assertEquals(data['name'], updates['name'])
self.assertEquals(data['active'], updates['active'])
self.assertEquals(data['hidden'], updates['hidden'])
self.assertEquals(data['details'], updates['details'])
def test_get_services(self):
""" Test index page api/infrastructure/service_records """
response = self.client.get(
path=reverse('api_infrastructure_service_records'), **self.authentication_headers)
self.assertEquals(response.status_code, 200)
def test_get_service(self):
response = self.client.get(path=reverse('api_infrastructure_service_records', kwargs={
'object_ptr': self.servicing.id}), **self.authentication_headers)
self.assertEquals(response.status_code, 200)
def test_update_service(self):
updates = {"name": "Api servicing", "items": [self.item.id], "start_date": "2011-06-01",
"expiry_date": "2011-10-01", "details": "Api details"}
response = self.client.put(path=reverse('api_infrastructure_service_records', kwargs={'object_ptr': self.servicing.id}),
content_type=self.content_type, data=json.dumps(updates), **self.authentication_headers)
self.assertEquals(response.status_code, 200)
data = json.loads(response.content)
self.assertEquals(data['name'], updates['name'])
for i, item in enumerate(data['items']):
self.assertEquals(item['id'], updates['items'][i])
self.assertEquals(data['start_date'], updates['start_date'])
self.assertEquals(data['expiry_date'], updates['expiry_date'])
self.assertEquals(data['details'], updates['details'])
def test_get_items_list(self):
""" Test index page api/infrastructure/items """
response = self.client.get(
path=reverse('api_infrastructure_items'), **self.authentication_headers)
self.assertEquals(response.status_code, 200)
def test_get_item(self):
response = self.client.get(path=reverse('api_infrastructure_items', kwargs={
'object_ptr': self.item.id}), **self.authentication_headers)
self.assertEquals(response.status_code, 200)
def test_update_item(self):
pass
updates = {"name": "Close_API", "item_type": self.type.id,
"status": self.status.id, "test___1": "api test"}
response = self.client.put(path=reverse('api_infrastructure_items', kwargs={'object_ptr': self.item.id}),
content_type=self.content_type, data=json.dumps(updates), **self.authentication_headers)
print response.content
self.assertEquals(response.status_code, 200)
data = json.loads(response.content)
self.assertEquals(data['name'], updates['name'])
self.assertEquals(data['item_type']['id'], updates['item_type'])
self.assertEquals(data['status']['id'], updates['status'])
self.assertEquals(
data['itemvalue_set'][0]["value"], updates['test___1'])
class SalesAPITest(TestCase):
"Sales functional tests for views"
username = "******"
password = "******"
prepared = False
authentication_headers = {
"CONTENT_TYPE": "application/json",
"HTTP_AUTHORIZATION": "Basic YXBpX3Rlc3Q6YXBpX3Bhc3N3b3Jk"
}
content_type = 'application/json'
def setUp(self):
"Initial Setup"
if not self.prepared:
# Clean up first
Object.objects.all().delete()
User.objects.all().delete()
# Create objects
try:
self.group = Group.objects.get(name='test')
except Group.DoesNotExist:
Group.objects.all().delete()
self.group = Group(name='test')
self.group.save()
try:
self.user = DjangoUser.objects.get(username=self.username)
self.user.set_password(self.password)
try:
self.profile = self.user.get_profile()
except Exception:
User.objects.all().delete()
self.user = DjangoUser(username=self.username, password='')
self.user.set_password(self.password)
self.user.save()
except DjangoUser.DoesNotExist:
User.objects.all().delete()
self.user = DjangoUser(username=self.username, password='')
self.user.set_password(self.password)
self.user.save()
try:
perspective = Perspective.objects.get(name='default')
except Perspective.DoesNotExist:
Perspective.objects.all().delete()
perspective = Perspective(name='default')
perspective.set_default_user()
perspective.save()
ModuleSetting.set('default_perspective', perspective.id)
self.contact_type = ContactType()
self.contact_type.slug = 'machine'
self.contact_type.name = 'machine'
self.contact_type.save()
self.contact = Contact()
self.contact.contact_type = self.contact_type
self.contact.set_default_user()
self.contact.save()
self.assertNotEquals(self.contact.id, None)
self.status = SaleStatus()
self.status.active = True
self.status.use_sales = True
self.status.use_leads = True
self.status.use_opportunities = True
self.status.set_default_user()
self.status.save()
self.assertNotEquals(self.status.id, None)
self.currency = Currency(code="GBP",
name="Pounds",
symbol="L",
is_default=True)
self.currency.save()
self.source = SaleSource()
self.source.active = True
self.source.save()
self.source.set_user(self.user)
self.assertNotEquals(self.source.id, None)
self.product = Product(name="Test")
self.product.product_type = 'service'
self.product.active = True
self.product.sell_price = 10
self.product.buy_price = 100
self.product.set_default_user()
self.product.save()
self.assertNotEquals(self.product.id, None)
self.subscription = Subscription()
self.subscription.client = self.contact
self.subscription.set_default_user()
self.subscription.save()
self.assertNotEquals(self.subscription.id, None)
self.lead = Lead()
self.lead.contact_method = 'email'
self.lead.status = self.status
self.lead.contact = self.contact
self.lead.set_default_user()
self.lead.save()
self.assertNotEquals(self.lead.id, None)
self.opportunity = Opportunity()
self.opportunity.lead = self.lead
self.opportunity.contact = self.contact
self.opportunity.status = self.status
self.opportunity.amount = 100
self.opportunity.amount_currency = self.currency
self.opportunity.amount_display = 120
self.opportunity.set_default_user()
self.opportunity.save()
self.assertNotEquals(self.opportunity.id, None)
self.order = SaleOrder(reference="Test")
self.order.opportunity = self.opportunity
self.order.status = self.status
self.order.source = self.source
self.order.currency = self.currency
self.order.total = 0
self.order.total_display = 0
self.order.set_default_user()
self.order.save()
self.assertNotEquals(self.order.id, None)
self.ordered_product = OrderedProduct()
self.ordered_product.product = self.product
self.ordered_product.order = self.order
self.ordered_product.rate = 0
self.ordered_product.subscription = self.subscription
self.ordered_product.set_default_user()
self.ordered_product.save()
self.assertNotEquals(self.ordered_product.id, None)
self.client = Client()
self.prepared = True
def test_unauthenticated_access(self):
"Test index page at /sales/statuses"
response = self.client.get('/api/sales/statuses')
# Redirects as unauthenticated
self.assertEquals(response.status_code, 401)
def test_get_statuses_list(self):
""" Test index page api/sales/status """
response = self.client.get(path=reverse('api_sales_status'),
**self.authentication_headers)
self.assertEquals(response.status_code, 200)
def test_get_status(self):
response = self.client.get(path=reverse(
'api_sales_status', kwargs={'object_ptr': self.status.id}),
**self.authentication_headers)
self.assertEquals(response.status_code, 200)
def test_update_status(self):
updates = {
"name": "Close_API",
"active": True,
"details": "api test details",
"use_leads": True,
"use_opportunities": True,
"hidden": False
}
response = self.client.put(path=reverse(
'api_sales_status', kwargs={'object_ptr': self.status.id}),
content_type=self.content_type,
data=json.dumps(updates),
**self.authentication_headers)
self.assertEquals(response.status_code, 200)
data = json.loads(response.content)
self.assertEquals(data['name'], updates['name'])
self.assertEquals(data['active'], updates['active'])
self.assertEquals(data['details'], updates['details'])
self.assertEquals(data['use_leads'], updates['use_leads'])
self.assertEquals(data['use_opportunities'],
updates['use_opportunities'])
self.assertEquals(data['hidden'], updates['hidden'])
def test_get_products_list(self):
""" Test index page api/sales/products """
response = self.client.get(path=reverse('api_sales_products'),
**self.authentication_headers)
self.assertEquals(response.status_code, 200)
def test_get_product(self):
response = self.client.get(path=reverse(
'api_sales_products', kwargs={'object_ptr': self.product.id}),
**self.authentication_headers)
self.assertEquals(response.status_code, 200)
def test_update_product(self):
updates = {
"name": "API product",
"parent": None,
"product_type": "service",
"code": "api_test_code",
"buy_price": '100.05',
"sell_price": '10.5',
"active": True,
"runout_action": "ignore",
"details": "api details"
}
response = self.client.put(path=reverse(
'api_sales_products', kwargs={'object_ptr': self.product.id}),
content_type=self.content_type,
data=json.dumps(updates),
**self.authentication_headers)
self.assertEquals(response.status_code, 200)
data = json.loads(response.content)
self.assertEquals(data['name'], updates['name'])
self.assertEquals(data['product_type'], updates['product_type'])
self.assertEquals(data['code'], updates['code'])
self.assertEquals(data['buy_price'], updates['buy_price'])
self.assertEquals(data['sell_price'], updates['sell_price'])
self.assertEquals(data['active'], updates['active'])
self.assertEquals(data['runout_action'], updates['runout_action'])
self.assertEquals(data['details'], updates['details'])
def test_get_sources_list(self):
""" Test index page api/sales/sources """
response = self.client.get(path=reverse('api_sales_sources'),
**self.authentication_headers)
self.assertEquals(response.status_code, 200)
def test_get_source(self):
response = self.client.get(path=reverse(
'api_sales_sources', kwargs={'object_ptr': self.source.id}),
**self.authentication_headers)
self.assertEquals(response.status_code, 200)
def test_update_source(self):
updates = {
"name": "Api source",
"active": True,
"details": "api details"
}
response = self.client.put(path=reverse(
'api_sales_sources', kwargs={'object_ptr': self.source.id}),
content_type=self.content_type,
data=json.dumps(updates),
**self.authentication_headers)
self.assertEquals(response.status_code, 200)
data = json.loads(response.content)
self.assertEquals(data['name'], updates['name'])
self.assertEquals(data['active'], updates['active'])
self.assertEquals(data['details'], updates['details'])
#
def test_get_leads_list(self):
""" Test index page api/sales/leads """
response = self.client.get(path=reverse('api_sales_leads'),
**self.authentication_headers)
self.assertEquals(response.status_code, 200)
def test_get_lead(self):
response = self.client.get(path=reverse(
'api_sales_leads', kwargs={'object_ptr': self.lead.id}),
**self.authentication_headers)
self.assertEquals(response.status_code, 200)
def test_update_lead(self):
updates = {
"status": self.status.id,
"contact_method": "email",
"contact": self.contact.id,
"products_interested": [self.product.id],
"source": self.source.id,
'details': 'Api details'
}
response = self.client.put(path=reverse(
'api_sales_leads', kwargs={'object_ptr': self.lead.id}),
content_type=self.content_type,
data=json.dumps(updates),
**self.authentication_headers)
self.assertEquals(response.status_code, 200)
data = json.loads(response.content)
self.assertEquals(data['status']['id'], updates['status'])
self.assertEquals(data['contact_method'], updates['contact_method'])
self.assertEquals(data['contact']['id'], updates['contact'])
for i, product in enumerate(data['products_interested']):
self.assertEquals(product['id'], updates['products_interested'][i])
self.assertEquals(data['source']['id'], updates['source'])
self.assertEquals(data['details'], updates['details'])
def test_get_opportunities_list(self):
""" Test index page api/sales/opportunities """
response = self.client.get(path=reverse('api_sales_opportunities'),
**self.authentication_headers)
self.assertEquals(response.status_code, 200)
def test_get_opportunity(self):
response = self.client.get(path=reverse(
'api_sales_opportunities',
kwargs={'object_ptr': self.opportunity.id}),
**self.authentication_headers)
self.assertEquals(response.status_code, 200)
def test_update_opportunity(self):
updates = {
"status": self.status.id,
"products_interested": [self.product.id],
"contact": self.contact.id,
"amount_display": 3000.56,
"amount_currency": self.currency.id,
"details": "API DETAILS"
}
response = self.client.put(path=reverse(
'api_sales_opportunities',
kwargs={'object_ptr': self.opportunity.id}),
content_type=self.content_type,
data=json.dumps(updates),
**self.authentication_headers)
self.assertEquals(response.status_code, 200)
data = json.loads(response.content)
self.assertEquals(data['status']['id'], updates['status'])
self.assertEquals(data['contact']['id'], updates['contact'])
for i, product in enumerate(data['products_interested']):
self.assertEquals(product['id'], updates['products_interested'][i])
self.assertEquals(data['amount_currency']['id'],
updates['amount_currency'])
self.assertEquals(data['details'], updates['details'])
def test_get_orders_list(self):
""" Test index page api/sales/orders """
response = self.client.get(path=reverse('api_sales_orders'),
**self.authentication_headers)
self.assertEquals(response.status_code, 200)
def test_get_order(self):
response = self.client.get(path=reverse(
'api_sales_orders', kwargs={'object_ptr': self.order.id}),
**self.authentication_headers)
self.assertEquals(response.status_code, 200)
def test_update_order(self):
updates = {
"datetime": "2011-04-11 12:01:15",
"status": self.status.id,
"source": self.source.id,
"details": "api details"
}
response = self.client.put(path=reverse(
'api_sales_orders', kwargs={'object_ptr': self.order.id}),
content_type=self.content_type,
data=json.dumps(updates),
**self.authentication_headers)
self.assertEquals(response.status_code, 200)
data = json.loads(response.content)
self.assertEquals(data['status']['id'], updates['status'])
self.assertEquals(data['source']['id'], updates['source'])
self.assertEquals(data['details'], updates['details'])
def test_get_subscriptions_list(self):
""" Test index page api/sales/subscriptions"""
response = self.client.get(path=reverse('api_sales_subscriptions'),
**self.authentication_headers)
self.assertEquals(response.status_code, 200)
def test_get_subscription(self):
response = self.client.get(path=reverse(
'api_sales_subscriptions',
kwargs={'object_ptr': self.subscription.id}),
**self.authentication_headers)
self.assertEquals(response.status_code, 200)
def test_update_subscription(self):
updates = {
"product": self.product.id,
"start": "2011-06-30",
"cycle_period": "daily",
"active": True,
"details": "api details"
}
response = self.client.put(path=reverse(
'api_sales_subscriptions',
kwargs={'object_ptr': self.subscription.id}),
content_type=self.content_type,
data=json.dumps(updates),
**self.authentication_headers)
self.assertEquals(response.status_code, 200)
data = json.loads(response.content)
self.assertEquals(data['product']['id'], updates['product'])
self.assertEquals(data['cycle_period'], updates['cycle_period'])
self.assertEquals(data['active'], updates['active'])
self.assertEquals(data['details'], updates['details'])
def test_get_ordered_product(self):
response = self.client.get(path=reverse(
'api_sales_ordered_products',
kwargs={'object_ptr': self.ordered_product.id}),
**self.authentication_headers)
self.assertEquals(response.status_code, 200)
def test_update_ordered_product(self):
updates = {
"discount": '10.0',
"product": self.product.id,
"quantity": '10'
}
response = self.client.put(path=reverse(
'api_sales_ordered_products',
kwargs={'object_ptr': self.ordered_product.id}),
content_type=self.content_type,
data=json.dumps(updates),
**self.authentication_headers)
self.assertEquals(response.status_code, 200)
data = json.loads(response.content)
self.assertEquals(data['product']['id'], updates['product'])
self.assertEquals(data['discount'], updates['discount'])
self.assertEquals(data['quantity'], updates['quantity'])
class EventsViewsTest(TestCase):
"Events functional tests for views"
username = "******"
password = "******"
prepared = False
def setUp(self):
"Initial Setup"
if not self.prepared:
# Clean up first
Object.objects.all().delete()
# Create objects
try:
self.group = Group.objects.get(name='test')
except Group.DoesNotExist:
Group.objects.all().delete()
self.group = Group(name='test')
self.group.save()
try:
self.user = DjangoUser.objects.get(username=self.username)
self.user.set_password(self.password)
try:
self.profile = self.user.get_profile()
except Exception:
User.objects.all().delete()
self.user = DjangoUser(username=self.username, password='')
self.user.set_password(self.password)
self.user.save()
except DjangoUser.DoesNotExist:
User.objects.all().delete()
self.user = DjangoUser(username=self.username, password='')
self.user.set_password(self.password)
self.user.save()
try:
perspective = Perspective.objects.get(name='default')
except Perspective.DoesNotExist:
Perspective.objects.all().delete()
perspective = Perspective(name='default')
perspective.set_default_user()
perspective.save()
ModuleSetting.set('default_perspective', perspective.id)
self.event = Event(name='TestStatus', end=datetime.now())
self.event.set_default_user()
self.event.save()
self.client = Client()
self.prepared = True
######################################
# Testing views when user is logged in
######################################
def test_index(self):
"Test index page with login at /calendar/index"
response = self.client.post('/accounts/login',
{'username': self.username, 'password': self.password })
self.assertRedirects(response, '/')
response = self.client.get(reverse('events_index'))
self.assertEquals(response.status_code, 200)
def test_upcoming(self):
"Test index page with login at /calendar/upcoming"
response = self.client.post('/accounts/login',
{'username': self.username, 'password': self.password })
self.assertRedirects(response, '/')
response = self.client.get(reverse('events_upcoming'))
self.assertEquals(response.status_code, 200)
def test_month(self):
"Test index page with login at /calendar/month"
response = self.client.post('/accounts/login',
{'username': self.username, 'password': self.password })
self.assertRedirects(response, '/')
response = self.client.get(reverse('events_month'))
self.assertEquals(response.status_code, 200)
def test_week(self):
"Test index page with login at /calendar/week"
response = self.client.post('/accounts/login',
{'username': self.username, 'password': self.password })
self.assertRedirects(response, '/')
response = self.client.get(reverse('events_week'))
self.assertEquals(response.status_code, 200)
def test_day(self):
"Test index page with login at /calendar/day"
response = self.client.post('/accounts/login',
{'username': self.username, 'password': self.password })
self.assertRedirects(response, '/')
response = self.client.get(reverse('events_day'))
self.assertEquals(response.status_code, 200)
# Events
def test_event_add(self):
"Test index page with login at /calendar/event/view/<event_id>"
response = self.client.post('/accounts/login',
{'username': self.username, 'password': self.password })
self.assertRedirects(response, '/')
response = self.client.get(reverse('events_event_add'))
self.assertEquals(response.status_code, 200)
# form
num_objects = Event.objects.count()
self.assertEquals(Event.objects.count(), 1)
post_data = {'name': 'TestStatus',
'end': datetime.now()
}
response = self.client.post(reverse('events_event_add'), post_data)
#self.assertEquals(response.status_code, 302) # redirect somewhere
#self.assertEquals(Event.objects.count(), num_objects + 1)
def test_event_view(self):
"Test index page with login at /calendar/event/view/<event_id>"
response = self.client.post('/accounts/login',
{'username': self.username, 'password': self.password })
self.assertRedirects(response, '/')
response = self.client.get(reverse('events_event_view', args=[self.event.id]))
self.assertEquals(response.status_code, 200)
def test_event_edit(self):
"Test index page with login at /calendar/event/edit/<event_id>"
response = self.client.post('/accounts/login',
{'username': self.username, 'password': self.password })
self.assertRedirects(response, '/')
response = self.client.get(reverse('events_event_edit', args=[self.event.id]))
self.assertEquals(response.status_code, 200)
def test_event_delete(self):
"Test index page with login at /calendar/event/delete/<event_id>"
response = self.client.post('/accounts/login',
{'username': self.username, 'password': self.password })
self.assertRedirects(response, '/')
response = self.client.get(reverse('events_event_delete', args=[self.event.id]))
self.assertEquals(response.status_code, 200)
# Integration
def test_events_settings_view(self):
"Test index page with login at /events/integration/"
response = self.client.post('/accounts/login',
{'username': self.username, 'password': self.password })
self.assertRedirects(response, '/')
response = self.client.get(reverse('events_integration_index'))
self.assertEquals(response.status_code, 200)
######################################
# Testing views when user is not logged in
######################################
def test_index_anonymous(self):
"Test index page at /calendar/"
response = self.client.get(reverse('events'))
# Redirects as unauthenticated
self.assertRedirects(response, reverse('user_login'))
def test_index_out(self):
"Testing /calendar/index"
response = self.client.get(reverse('events_index'))
self.assertRedirects(response, reverse('user_login'))
def test_upcoming_out(self):
"Testing /calendar/upcoming"
response = self.client.get(reverse('events_upcoming'))
self.assertRedirects(response, reverse('user_login'))
def test_month_out(self):
"Testing /calendar/month"
response = self.client.get(reverse('events_month'))
self.assertRedirects(response, reverse('user_login'))
def test_week_out(self):
"Testing /calendar/week"
response = self.client.get(reverse('events_week'))
self.assertRedirects(response, reverse('user_login'))
def test_day_out(self):
"Testing /calendar/day"
response = self.client.get(reverse('events_day'))
self.assertRedirects(response, reverse('user_login'))
# Events
def test_event_add_out(self):
"Testing /calendar/event/view/<event_id>"
response = self.client.get(reverse('events_event_add'))
self.assertRedirects(response, reverse('user_login'))
def test_event_view_out(self):
"Testing /calendar/event/view/<event_id>"
response = self.client.get(reverse('events_event_view', args=[self.event.id]))
self.assertRedirects(response, reverse('user_login'))
def test_event_edit_out(self):
"Testing /calendar/event/edit/<event_id>"
response = self.client.get(reverse('events_event_edit', args=[self.event.id]))
self.assertRedirects(response, reverse('user_login'))
def test_event_delete_out(self):
"Testing /calendar/event/delete/<event_id>"
response = self.client.get(reverse('events_event_delete', args=[self.event.id]))
self.assertRedirects(response, reverse('user_login'))
# Integration
def test_events_settings_view_out(self):
"Testing /events/integration/"
response = self.client.get(reverse('events_integration_index'))
self.assertRedirects(response, reverse('user_login'))
class CoreAPITest(TestCase):
"Core api tests"
username = "******"
password = "******"
prepared = False
authentication_headers = {
"CONTENT_TYPE": "application/json",
"HTTP_AUTHORIZATION": "Basic YXBpX3Rlc3Q6YXBpX3Bhc3N3b3Jk"
}
content_type = 'application/json'
prepared = False
def setUp(self):
"Initial Setup"
if not self.prepared:
Object.objects.all().delete()
# Create objects
self.group, created = Group.objects.get_or_create(name='test')
duser, created = DjangoUser.objects.get_or_create(
username=self.username)
duser.set_password(self.password)
duser.save()
self.user, created = User.objects.get_or_create(user=duser)
self.user.save()
perspective, created = Perspective.objects.get_or_create(
name='default')
perspective.set_default_user()
perspective.save()
ModuleSetting.set('default_perspective', perspective.id)
self.perspective = Perspective(name='test')
self.perspective.set_default_user()
self.perspective.save()
self.group = Group(name='test')
self.group.save()
self.client = Client()
self.prepared = True
def test_unauthenticated_access(self):
"Test index page at /admin/api/users"
response = self.client.get('/admin/api/users')
# Redirects as unauthenticated
self.assertEquals(response.status_code, 404)
def test_get_ticket_groups_list(self):
""" Test index page api /admin/api/groups """
response = self.client.get(path=reverse('api_admin_groups'),
**self.authentication_headers)
self.assertEquals(response.status_code, 200)
def test_get_group(self):
response = self.client.get(path=reverse(
'api_admin_groups', kwargs={'accessentity_ptr': self.group.id}),
**self.authentication_headers)
print response.content
self.assertEquals(response.status_code, 200)
def test_update_group(self):
updates = {
'name': 'Api group name',
'details': '<p>api details</p>',
'perspective': self.perspective.id
}
response = self.client.put(path=reverse(
'api_admin_groups', kwargs={'accessentity_ptr': self.group.id}),
content_type=self.content_type,
data=json.dumps(updates),
**self.authentication_headers)
print response.content
self.assertEquals(response.status_code, 200)
data = json.loads(response.content)
self.assertEquals(data['name'], updates['name'])
self.assertEquals(data['details'], updates['details'])
self.assertEquals(data['perspective']['id'], updates['perspective'])
def test_get_ticket_users_list(self):
""" Test index page api /admin/api/users """
response = self.client.get(path=reverse('api_admin_users'),
**self.authentication_headers)
self.assertEquals(response.status_code, 200)
def test_get_user(self):
response = self.client.get(path=reverse(
'api_admin_users', kwargs={'accessentity_ptr': self.user.id}),
**self.authentication_headers)
print response.content
self.assertEquals(response.status_code, 200)
def test_update_user(self):
updates = {
'name': 'Api user name',
'default_group': self.group.id,
'disabled': False,
'perspective': self.perspective.id
}
response = self.client.put(path=reverse(
'api_admin_users', kwargs={'accessentity_ptr': self.user.id}),
content_type=self.content_type,
data=json.dumps(updates),
**self.authentication_headers)
self.assertEquals(response.status_code, 405)
#data = json.loads(response.content)
#self.assertEquals(data['name'], updates['name'])
#self.assertEquals(data['disabled'], updates['disabled'])
#self.assertEquals(data['default_group']['id'], updates['default_group'])
#self.assertEquals(data['perspective']['id'], updates['perspective'])
def test_delete_self(self):
response = self.client.delete(path=reverse(
'api_admin_users', kwargs={'accessentity_ptr': self.user.id}),
**self.authentication_headers)
self.assertEquals(response.status_code, 401)
def test_get_ticket_modules_list(self):
""" Test index page api /admin/api/modules """
response = self.client.get(path=reverse('api_admin_modules'),
**self.authentication_headers)
self.assertEquals(response.status_code, 200)
def test_get_ticket_perspectives_list(self):
""" Test index page api /admin/api/perspectives """
response = self.client.get(path=reverse('api_admin_perspectives'),
**self.authentication_headers)
self.assertEquals(response.status_code, 200)
def test_get_perspective(self):
response = self.client.get(path=reverse(
'api_admin_perspectives',
kwargs={'object_ptr': self.perspective.id}),
**self.authentication_headers)
self.assertEquals(response.status_code, 200)
def test_update_perspective(self):
updates = {'name': 'Api perspective', 'details': 'Api details'}
response = self.client.put(path=reverse(
'api_admin_perspectives',
kwargs={'object_ptr': self.perspective.id}),
content_type=self.content_type,
data=json.dumps(updates),
**self.authentication_headers)
self.assertEquals(response.status_code, 200)
data = json.loads(response.content)
self.assertEquals(data['name'], updates['name'])
self.assertEquals(data['details'], updates['details'])
def setUp(self):
"Initial Setup"
if not self.prepared:
# Clean up first
Object.objects.all().delete()
User.objects.all().delete()
# Create objects
try:
self.group = Group.objects.get(name='test')
except Group.DoesNotExist:
Group.objects.all().delete()
self.group = Group(name='test')
self.group.save()
try:
self.user = DjangoUser.objects.get(username=self.username)
self.user.set_password(self.password)
try:
self.profile = self.user.get_profile()
except Exception:
User.objects.all().delete()
self.user = DjangoUser(username=self.username, password='')
self.user.set_password(self.password)
self.user.save()
except DjangoUser.DoesNotExist:
User.objects.all().delete()
self.user = DjangoUser(username=self.username, password='')
self.user.set_password(self.password)
self.user.save()
try:
perspective = Perspective.objects.get(name='default')
except Perspective.DoesNotExist:
Perspective.objects.all().delete()
perspective = Perspective(name='default')
perspective.set_default_user()
perspective.save()
ModuleSetting.set('default_perspective', perspective.id)
self.contact_type = ContactType()
self.contact_type.slug = 'machine'
self.contact_type.name = 'machine'
self.contact_type.save()
self.contact = Contact()
self.contact.contact_type = self.contact_type
self.contact.set_default_user()
self.contact.save()
self.assertNotEquals(self.contact.id, None)
self.status = SaleStatus()
self.status.active = True
self.status.use_sales = True
self.status.use_leads = True
self.status.use_opportunities = True
self.status.set_default_user()
self.status.save()
self.assertNotEquals(self.status.id, None)
self.currency = Currency(code="GBP",
name="Pounds",
symbol="L",
is_default=True)
self.currency.save()
self.source = SaleSource()
self.source.active = True
self.source.save()
self.source.set_user(self.user)
self.assertNotEquals(self.source.id, None)
self.product = Product(name="Test")
self.product.product_type = 'service'
self.product.active = True
self.product.sell_price = 10
self.product.buy_price = 100
self.product.set_default_user()
self.product.save()
self.assertNotEquals(self.product.id, None)
self.subscription = Subscription()
self.subscription.client = self.contact
self.subscription.set_default_user()
self.subscription.save()
self.assertNotEquals(self.subscription.id, None)
self.lead = Lead()
self.lead.contact_method = 'email'
self.lead.status = self.status
self.lead.contact = self.contact
self.lead.set_default_user()
self.lead.save()
self.assertNotEquals(self.lead.id, None)
self.opportunity = Opportunity()
self.opportunity.lead = self.lead
self.opportunity.contact = self.contact
self.opportunity.status = self.status
self.opportunity.amount = 100
self.opportunity.amount_currency = self.currency
self.opportunity.amount_display = 120
self.opportunity.set_default_user()
self.opportunity.save()
self.assertNotEquals(self.opportunity.id, None)
self.order = SaleOrder(reference="Test")
self.order.opportunity = self.opportunity
self.order.status = self.status
self.order.source = self.source
self.order.currency = self.currency
self.order.total = 0
self.order.total_display = 0
self.order.set_default_user()
self.order.save()
self.assertNotEquals(self.order.id, None)
self.ordered_product = OrderedProduct()
self.ordered_product.product = self.product
self.ordered_product.order = self.order
self.ordered_product.rate = 0
self.ordered_product.subscription = self.subscription
self.ordered_product.set_default_user()
self.ordered_product.save()
self.assertNotEquals(self.ordered_product.id, None)
self.client = Client()
self.prepared = True
class KnowledgeViewsTest(TestCase):
"Knowledge functional tests for views"
username = "******"
password = "******"
prepared = False
def setUp(self):
"Initial Setup"
if not self.prepared:
# Clean up first
Object.objects.all().delete()
# Create objects
try:
self.group = Group.objects.get(name='test')
except Group.DoesNotExist:
Group.objects.all().delete()
self.group = Group(name='test')
self.group.save()
try:
self.user = DjangoUser.objects.get(username=self.username)
self.user.set_password(self.password)
try:
self.profile = self.user.get_profile()
except Exception:
User.objects.all().delete()
self.user = DjangoUser(username=self.username, password='')
self.user.set_password(self.password)
self.user.save()
except DjangoUser.DoesNotExist:
User.objects.all().delete()
self.user = DjangoUser(username=self.username, password='')
self.user.set_password(self.password)
self.user.save()
try:
perspective = Perspective.objects.get(name='default')
except Perspective.DoesNotExist:
Perspective.objects.all().delete()
perspective = Perspective(name='default')
perspective.set_default_user()
perspective.save()
ModuleSetting.set('default_perspective', perspective.id)
self.folder = KnowledgeFolder(name='test', treepath='test')
self.folder.set_default_user()
self.folder.save()
self.category = KnowledgeCategory(name='test', treepath='test')
self.category.set_default_user()
self.category.save()
self.item = KnowledgeItem(name='test', folder=self.folder,
category=self.category, treepath='test')
self.item.set_default_user()
self.item.save()
# parent folder
self.parent = KnowledgeFolder(name='test', treepath='test')
self.parent.set_default_user()
self.parent.save()
self.client = Client()
self.prepared = True
######################################
# Testing views when user is logged in
######################################
def test_index_login(self):
"Test index page with login at /knowledge/"
response = self.client.post('/accounts/login',
{'username': self.username, 'password': self.password })
self.assertRedirects(response, '/')
response = self.client.get(reverse('knowledge'))
self.assertEquals(response.status_code, 200)
def test_index_categories_login(self):
"Test index page with login at /knowledge/categories/"
response = self.client.post('/accounts/login',
{'username': self.username, 'password': self.password })
self.assertRedirects(response, '/')
response = self.client.get(reverse('knowledge_categories'))
self.assertEquals(response.status_code, 200)
# Knowledge folders
def test_knowledge_folder_add(self):
"Test index page with login at /knowledge/folder/add/"
response = self.client.post('/accounts/login',
{'username': self.username, 'password': self.password })
self.assertRedirects(response, '/')
response = self.client.get(reverse('knowledge_folder_add'))
self.assertEquals(response.status_code, 200)
def test_knowledge_folder_add_typed(self):
"Test index page with login at /knowledge/folder/add/<folderPath>"
response = self.client.post('/accounts/login',
{'username': self.username, 'password': self.password })
self.assertRedirects(response, '/')
response = self.client.get(reverse('knowledge_folder_add_folder', args=[self.parent.treepath]))
self.assertEquals(response.status_code, 200)
def test_knowledge_folder_view(self):
"Test index page with login at /knowledge/folder/view/<knowledgeType_id>"
response = self.client.post('/accounts/login',
{'username': self.username, 'password': self.password })
self.assertRedirects(response, '/')
response = self.client.get(reverse('knowledge_folder_view', args=[self.folder.treepath]))
self.assertEquals(response.status_code, 200)
def test_knowledge_folder_edit(self):
"Test index page with login at /knowledge/folder/edit/<knowledgeType_id>"
response = self.client.post('/accounts/login',
{'username': self.username, 'password': self.password })
self.assertRedirects(response, '/')
response = self.client.get(reverse('knowledge_folder_edit', args=[self.folder.id]))
self.assertEquals(response.status_code, 200)
def test_knowledge_folder_delete(self):
"Test index page with login at /knowledge/folder/delete/<knowledgeType_id>"
response = self.client.post('/accounts/login',
{'username': self.username, 'password': self.password })
self.assertRedirects(response, '/')
response = self.client.get(reverse('knowledge_folder_delete', args=[self.folder.id]))
self.assertEquals(response.status_code, 200)
# Knowledge items
def test_knowledge_item_add(self):
"Test index page with login at /knowledge/item/add"
response = self.client.post('/accounts/login',
{'username': self.username, 'password': self.password })
self.assertRedirects(response, '/')
response = self.client.get(reverse('knowledge_item_add'))
self.assertEquals(response.status_code, 200)
def test_knowledge_item_add_typed(self):
"Test index page with login at /knowledge/item/add/<folderPath>"
response = self.client.post('/accounts/login',
{'username': self.username, 'password': self.password })
self.assertRedirects(response, '/')
response = self.client.get(reverse('knowledge_item_add_folder', args=[self.folder.treepath]))
self.assertEquals(response.status_code, 200)
def test_knowledge_item_view(self):
"Test index page with login at /knowledge/item/view/<knowledgeItem_id>"
response = self.client.post('/accounts/login',
{'username': self.username, 'password': self.password })
self.assertRedirects(response, '/')
response = self.client.get(reverse('knowledge_item_view',
args=[self.item.folder.treepath, self.item.treepath]))
self.assertEquals(response.status_code, 200)
def test_knowledge_item_edit(self):
"Test index page with login at /knowledge/item/edit/<knowledgeItem_id>"
response = self.client.post('/accounts/login',
{'username': self.username, 'password': self.password })
self.assertRedirects(response, '/')
response = self.client.get(reverse('knowledge_item_edit', args=[self.item.id]))
self.assertEquals(response.status_code, 200)
def test_knowledge_item_delete(self):
"Test index page with login at /knowledge/item/delete/<knowledgeItem_id>"
response = self.client.post('/accounts/login',
{'username': self.username, 'password': self.password })
self.assertRedirects(response, '/')
response = self.client.get(reverse('knowledge_item_delete', args=[self.item.id]))
self.assertEquals(response.status_code, 200)
# Knowledge categories
def test_knowledge_category_add(self):
"Test index page with login at /knowledge/category/add"
response = self.client.post('/accounts/login',
{'username': self.username, 'password': self.password })
self.assertRedirects(response, '/')
response = self.client.get(reverse('knowledge_category_add'))
self.assertEquals(response.status_code, 200)
def test_knowledge_category_view(self):
"Test index page with login at /knowledge/category/view/<knowledgeCategory_id>"
response = self.client.post('/accounts/login',
{'username': self.username, 'password': self.password })
self.assertRedirects(response, '/')
response = self.client.get(reverse('knowledge_category_view', args=[self.category.treepath]))
self.assertEquals(response.status_code, 200)
def test_knowledge_category_edit(self):
"Test index page with login at /knowledge/category/edit/<knowledgeCategory_id>"
response = self.client.post('/accounts/login',
{'username': self.username, 'password': self.password })
self.assertRedirects(response, '/')
response = self.client.get(reverse('knowledge_category_edit', args=[self.category.id]))
self.assertEquals(response.status_code, 200)
def test_knowledge_category_delete(self):
"Test index page with login at /knowledge/category/delete/<knowledgeCategory_id>"
response = self.client.post('/accounts/login',
{'username': self.username, 'password': self.password })
self.assertRedirects(response, '/')
response = self.client.get(reverse('knowledge_category_delete', args=[self.category.id]))
self.assertEquals(response.status_code, 200)
######################################
# Testing views when user is not logged in
######################################
def test_index(self):
"Test index page at /knowledge/"
response = self.client.get('/knowledge/')
# Redirects as unauthenticated
self.assertRedirects(response, reverse('user_login'))
def test_index_categories_out(self):
"Testing /knowledge/categories/"
response = self.client.get(reverse('knowledge_categories'))
self.assertRedirects(response, reverse('user_login'))
# Knowledge folders
def test_knowledge_folder_add_out(self):
"Testing /knowledge/folder/add/"
response = self.client.get(reverse('knowledge_folder_add'))
self.assertRedirects(response, reverse('user_login'))
def test_knowledge_folder_add_typed_out(self):
"Testing /knowledge/folder/add/<folderPath>"
response = self.client.get(reverse('knowledge_folder_add_folder', args=[self.parent.treepath]))
self.assertRedirects(response, reverse('user_login'))
def test_knowledge_folder_view_out(self):
"Testing /knowledge/folder/view/<knowledgeType_id>"
response = self.client.get(reverse('knowledge_folder_view', args=[self.folder.treepath]))
self.assertRedirects(response, reverse('user_login'))
def test_knowledge_folder_edit_out(self):
"Testing /knowledge/folder/edit/<knowledgeType_id>"
response = self.client.get(reverse('knowledge_folder_edit', args=[self.folder.id]))
self.assertRedirects(response, reverse('user_login'))
def test_knowledge_folder_delete_out(self):
"Testing /knowledge/folder/delete/<knowledgeType_id>"
response = self.client.get(reverse('knowledge_folder_delete', args=[self.folder.id]))
self.assertRedirects(response, reverse('user_login'))
# Knowledge items
def test_knowledge_item_add_out(self):
"Testing /knowledge/item/add"
response = self.client.get(reverse('knowledge_item_add'))
self.assertRedirects(response, reverse('user_login'))
def test_knowledge_item_add_typed_out(self):
"Testing /knowledge/item/add/<folderPath>"
response = self.client.get(reverse('knowledge_item_add_folder', args=[self.folder.treepath]))
self.assertRedirects(response, reverse('user_login'))
def test_knowledge_item_view_out(self):
"Testing /knowledge/item/view/<knowledgeItem_id>"
response = self.client.get(reverse('knowledge_item_view',
args=[self.item.folder.treepath, self.item.treepath]))
self.assertRedirects(response, reverse('user_login'))
def test_knowledge_item_edit_out(self):
"Testing /knowledge/item/edit/<knowledgeItem_id>"
response = self.client.get(reverse('knowledge_item_edit', args=[self.item.id]))
self.assertRedirects(response, reverse('user_login'))
def test_knowledge_item_delete_out(self):
"Testing /knowledge/item/delete/<knowledgeItem_id>"
response = self.client.get(reverse('knowledge_item_delete', args=[self.item.id]))
self.assertRedirects(response, reverse('user_login'))
# Knowledge categories
def test_knowledge_category_add_out(self):
"Testing /knowledge/category/add"
response = self.client.get(reverse('knowledge_category_add'))
self.assertRedirects(response, reverse('user_login'))
def test_knowledge_category_view_out(self):
"Testing /knowledge/category/view/<knowledgeCategory_id>"
response = self.client.get(reverse('knowledge_category_view', args=[self.category.treepath]))
self.assertRedirects(response, reverse('user_login'))
def test_knowledge_category_edit_out(self):
"Testing /knowledge/category/edit/<knowledgeCategory_id>"
response = self.client.get(reverse('knowledge_category_edit', args=[self.category.id]))
self.assertRedirects(response, reverse('user_login'))
def test_knowledge_category_delete_out(self):
"Testing /knowledge/category/delete/<knowledgeCategory_id>"
response = self.client.get(reverse('knowledge_category_delete', args=[self.category.id]))
self.assertRedirects(response, reverse('user_login'))
class MessagingApiTest(TestCase):
"Messaging functional tests for api"
username = "******"
password = "******"
prepared = False
authentication_headers ={"CONTENT_TYPE": "application/json",
"HTTP_AUTHORIZATION" : "Basic YXBpX3Rlc3Q6YXBpX3Bhc3N3b3Jk" }
content_type ='application/json'
def setUp(self):
"Initial Setup"
if not self.prepared:
# Clean up first
Object.objects.all().delete()
# Create objects
try:
self.group = Group.objects.get(name='test')
except Group.DoesNotExist:
Group.objects.all().delete()
self.group = Group(name='test')
self.group.save()
try:
self.user = DjangoUser.objects.get(username=self.username)
self.user.set_password(self.password)
try:
self.profile = self.user.get_profile()
except Exception:
User.objects.all().delete()
self.user = DjangoUser(username=self.username, password='')
self.user.set_password(self.password)
self.user.save()
except DjangoUser.DoesNotExist:
User.objects.all().delete()
self.user = DjangoUser(username=self.username, password='')
self.user.set_password(self.password)
self.user.save()
try:
perspective = Perspective.objects.get(name='default')
except Perspective.DoesNotExist:
Perspective.objects.all().delete()
perspective = Perspective(name='default')
perspective.set_default_user()
perspective.save()
ModuleSetting.set('default_perspective', perspective.id)
self.contact_type = ContactType(name='test')
self.contact_type.set_default_user()
self.contact_type.save()
self.contact = Contact(name='test', contact_type=self.contact_type)
self.contact.set_default_user()
self.contact.save()
self.user_contact = Contact(name='test', related_user=self.user.get_profile(), contact_type=self.contact_type)
self.user_contact.set_user(self.user)
self.user_contact.save()
self.stream = MessageStream(name='test')
self.stream.set_default_user()
self.stream.save()
self.mlist = MailingList(name='test', from_contact=self.contact)
self.mlist.set_default_user()
self.mlist.save()
self.message = Message(title='test', body='test', author=self.contact, stream=self.stream)
self.message.set_default_user()
self.message.save()
self.client = Client()
self.prepared = True
def test_unauthenticated_access(self):
"Test index page at /api/messaging/mlist"
response = self.client.get('/api/messaging/mlist')
# Redirects as unauthenticated
self.assertEquals(response.status_code, 401)
def test_get_mlist(self):
""" Test index page api/messaging/mlist """
response = self.client.get(path=reverse('api_messaging_mlist'), **self.authentication_headers)
self.assertEquals(response.status_code, 200)
def test_get_one_mlist(self):
response = self.client.get(path=reverse('api_messaging_mlist', kwargs={'object_ptr': self.mlist.id}), **self.authentication_headers)
self.assertEquals(response.status_code, 200)
def test_update_mlist(self):
updates = {"name": "API mailing list", "description": "API description update", "from_contact": self.contact.id,
"members": [self.contact.id,]}
response = self.client.put(path=reverse('api_messaging_mlist', kwargs={'object_ptr': self.mlist.id}),
content_type=self.content_type, data=json.dumps(updates), **self.authentication_headers)
self.assertEquals(response.status_code, 200)
data = json.loads(response.content)
self.assertEquals(data['name'], updates['name'])
self.assertEquals(data['description'], updates['description'])
self.assertEquals(data['from_contact']['id'], updates['from_contact'])
for i, member in enumerate(data['members']):
self.assertEquals(member['id'], updates['members'][i])
def test_get_streams(self):
""" Test index page api/messaging/streams """
response = self.client.get(path=reverse('api_messaging_streams'), **self.authentication_headers)
self.assertEquals(response.status_code, 200)
def test_get_stream(self):
response = self.client.get(path=reverse('api_messaging_streams', kwargs={'object_ptr': self.stream.id}), **self.authentication_headers)
self.assertEquals(response.status_code, 200)
def test_update_stream(self):
updates = {"name": "API stream", }
response = self.client.put(path=reverse('api_messaging_streams', kwargs={'object_ptr': self.stream.id}),
content_type=self.content_type, data=json.dumps(updates), **self.authentication_headers)
self.assertEquals(response.status_code, 200)
data = json.loads(response.content)
self.assertEquals(data['name'], updates['name'])
def test_get_messages(self):
""" Test index page api/messaging/messages """
response = self.client.get(path=reverse('api_messaging_messages'), **self.authentication_headers)
self.assertEquals(response.status_code, 200)
def test_get_message(self):
response = self.client.get(path=reverse('api_messaging_messages', kwargs={'object_ptr': self.message.id}), **self.authentication_headers)
self.assertEquals(response.status_code, 200)
def test_send_message(self):
updates = {"title": "API message title", "body": "Test body", "stream": self.stream.id,
"multicomplete_recipients": u'*****@*****.**'}
response = self.client.post(path=reverse('api_messaging_messages'), content_type=self.content_type,
data=json.dumps(updates), **self.authentication_headers)
self.assertEquals(response.status_code, 200)
data = json.loads(response.content)
self.assertEquals(data['title'], updates['title'])
self.assertEquals(data['body'], updates['body'])
self.assertEquals(data['stream']['id'], updates['stream'])
def test_reply_to_message(self):
updates = {"title": "API test", "body": "Test body", "stream": self.stream.id,
"multicomplete_recipients": u'*****@*****.**'}
response = self.client.put(path=reverse('api_messaging_messages', kwargs={'object_ptr': self.message.id}),
content_type=self.content_type, data=json.dumps(updates), **self.authentication_headers)
self.assertEquals(response.status_code, 200)
data = json.loads(response.content)
self.assertNotEquals(data['title'], updates['title'])
self.assertEquals(data['body'], updates['body'])
self.assertEquals(data['stream']['id'], updates['stream'])
class DocumentsViewsTest(TestCase):
"Documents functional tests for api"
username = "******"
password = "******"
prepared = False
authentication_headers = {
"CONTENT_TYPE": "application/json",
"HTTP_AUTHORIZATION": "Basic YXBpX3Rlc3Q6YXBpX3Bhc3N3b3Jk"
}
content_type = 'application/json'
def setUp(self):
"Initial Setup"
if not self.prepared:
Object.objects.all().delete()
# Create objects
try:
self.group = Group.objects.get(name='test')
except Group.DoesNotExist:
Group.objects.all().delete()
self.group = Group(name='test')
self.group.save()
try:
self.user = DjangoUser.objects.get(username=self.username)
self.user.set_password(self.password)
try:
self.profile = self.user.get_profile()
except Exception:
User.objects.all().delete()
self.user = DjangoUser(username=self.username, password='')
self.user.set_password(self.password)
self.user.save()
except DjangoUser.DoesNotExist:
User.objects.all().delete()
self.user = DjangoUser(username=self.username, password='')
self.user.set_password(self.password)
self.user.save()
try:
perspective = Perspective.objects.get(name='default')
except Perspective.DoesNotExist:
Perspective.objects.all().delete()
perspective = Perspective(name='default')
perspective.set_default_user()
perspective.save()
ModuleSetting.set('default_perspective', perspective.id)
self.folder = Folder(name='test')
self.folder.set_default_user()
self.folder.save()
self.document = Document(title='test_document', folder=self.folder)
self.document.set_default_user()
self.document.save()
self.file = File(name='test_file', folder=self.folder)
self.file.set_default_user()
self.file.save()
self.link = WebLink(title='test', folder=self.folder, url='test')
self.link.set_default_user()
self.link.save()
self.client = Client()
self.prepared = True
def test_unauthenticated_access(self):
"Test index page at /api/documents/folders"
response = self.client.get('/api/documents/folders')
# Redirects as unauthenticated
self.assertEquals(response.status_code, 401)
def test_get_folders_list(self):
""" Test index page api/documents/folders """
response = self.client.get(path=reverse('api_documents_folders'),
**self.authentication_headers)
self.assertEquals(response.status_code, 200)
def test_get_folder(self):
response = self.client.get(path=reverse(
'api_documents_folders', kwargs={'object_ptr': self.folder.id}),
**self.authentication_headers)
self.assertEquals(response.status_code, 200)
def test_update_folder(self):
updates = {"name": "Api_folder_name"}
response = self.client.put(path=reverse(
'api_documents_folders', kwargs={'object_ptr': self.folder.id}),
content_type=self.content_type,
data=json.dumps(updates),
**self.authentication_headers)
self.assertEquals(response.status_code, 200)
data = json.loads(response.content)
self.assertEquals(data['name'], updates['name'])
def test_get_files_list(self):
""" Test index page api/documents/files """
response = self.client.get(path=reverse('api_documents_files'),
**self.authentication_headers)
self.assertEquals(response.status_code, 200)
def test_get_file(self):
response = self.client.get(path=reverse(
'api_documents_files', kwargs={'object_ptr': self.file.id}),
**self.authentication_headers)
self.assertEquals(response.status_code, 200)
# def test_update_file(self):
# updates = { "name": "Api_folder_name" }
# response = self.client.put(path=reverse('api_documents_files', kwargs={'object_ptr': self.file.id}),
# content_type=self.content_type, data=json.dumps(updates), **self.authentication_headers)
# self.assertEquals(response.status_code, 200)
#
# data = json.loads(response.content)
# self.assertEquals(data['name'], updates['name'])
def test_get_documents_list(self):
""" Test index page api/documents/documents """
response = self.client.get(path=reverse('api_documents_documents'),
**self.authentication_headers)
self.assertEquals(response.status_code, 200)
def test_get_document(self):
response = self.client.get(
path=reverse('api_documents_documents',
kwargs={'object_ptr': self.document.id}),
**self.authentication_headers)
self.assertEquals(response.status_code, 200)
def test_update_document(self):
updates = {
"title": "Api_title",
"folder": self.folder.id,
"body": "Api test body"
}
response = self.client.put(
path=reverse('api_documents_documents',
kwargs={'object_ptr': self.document.id}),
content_type=self.content_type,
data=json.dumps(updates),
**self.authentication_headers)
self.assertEquals(response.status_code, 200)
data = json.loads(response.content)
self.assertEquals(data['title'], updates['title'])
self.assertEquals(data['folder']['id'], updates['folder'])
self.assertEquals(data['body'], updates['body'])
def test_get_weblinks_list(self):
""" Test index page api/documents/weblinks """
response = self.client.get(path=reverse('api_documents_weblinks'),
**self.authentication_headers)
self.assertEquals(response.status_code, 200)
def test_get_weblink(self):
response = self.client.get(path=reverse(
'api_documents_weblinks', kwargs={'object_ptr': self.link.id}),
**self.authentication_headers)
self.assertEquals(response.status_code, 200)
def test_update_weblink(self):
updates = {
"title": "Api_title",
"folder": self.folder.id,
"url": "http://Api-test-body"
}
response = self.client.put(path=reverse(
'api_documents_weblinks', kwargs={'object_ptr': self.link.id}),
content_type=self.content_type,
data=json.dumps(updates),
**self.authentication_headers)
self.assertEquals(response.status_code, 200)
data = json.loads(response.content)
self.assertEquals(data['title'], updates['title'])
self.assertEquals(data['folder']['id'], updates['folder'])
self.assertEquals(data['url'], updates['url'])
class InfrastructureViewsTest(TestCase):
"Infrastructure functional tests for views"
username = "******"
password = "******"
prepared = False
def setUp(self):
"Initial Setup"
if not self.prepared:
# Clean up first
Object.objects.all().delete()
# Create objects
try:
self.group = Group.objects.get(name='test')
except Group.DoesNotExist:
Group.objects.all().delete()
self.group = Group(name='test')
self.group.save()
try:
self.user = DjangoUser.objects.get(username=self.username)
self.user.set_password(self.password)
try:
self.profile = self.user.get_profile()
except Exception:
User.objects.all().delete()
self.user = DjangoUser(username=self.username, password='')
self.user.set_password(self.password)
self.user.save()
except DjangoUser.DoesNotExist:
User.objects.all().delete()
self.user = DjangoUser(username=self.username, password='')
self.user.set_password(self.password)
self.user.save()
try:
perspective = Perspective.objects.get(name='default')
except Perspective.DoesNotExist:
Perspective.objects.all().delete()
perspective = Perspective(name='default')
perspective.set_default_user()
perspective.save()
ModuleSetting.set('default_perspective', perspective.id)
self.type = ItemType(name='test')
self.type.set_default_user()
self.type.save()
self.status = ItemStatus(name='test')
self.status.set_default_user()
self.status.save()
self.field = ItemField(name='test', label='test', field_type='text')
self.field.set_default_user()
self.field.save()
self.item = Item(name='test', item_type=self.type, status=self.status)
self.item.set_default_user()
self.item.save()
self.value = ItemValue(field=self.field, item=self.item)
self.value.save()
self.servicing = ItemServicing(name='test')
self.servicing.set_default_user()
self.servicing.save()
self.client = Client()
self.prepared = True
######################################
# Testing views when user is logged in
######################################
def test_index_login(self):
"Test index page with login at /infrastructure/"
response = self.client.post('/accounts/login',
{'username': self.username, 'password': self.password })
self.assertRedirects(response, '/')
response = self.client.get(reverse('infrastructure'))
self.assertEquals(response.status_code, 200)
def test_index_infrastructure_login(self):
"Test index page with login at /infrastructure/index/"
response = self.client.post('/accounts/login',
{'username': self.username, 'password': self.password })
self.assertRedirects(response, '/')
response = self.client.get(reverse('infrastructure_index'))
self.assertEquals(response.status_code, 200)
def test_infrastructure_index_owned(self):
"Test index page with login at /infrastructure/owned/"
response = self.client.post('/accounts/login',
{'username': self.username, 'password': self.password })
self.assertRedirects(response, '/')
response = self.client.get(reverse('infrastructure_index_owned'))
self.assertEquals(response.status_code, 200)
# Type
def test_infrastructure_type_add(self):
"Test index page with login at /infrastructure/type/add/"
response = self.client.post('/accounts/login',
{'username': self.username, 'password': self.password })
self.assertRedirects(response, '/')
response = self.client.get(reverse('infrastructure_type_add'))
self.assertEquals(response.status_code, 200)
def test_infrastructure_type_view(self):
"Test index page with login at /infrastructure/type/view/<type_id>"
response = self.client.post('/accounts/login',
{'username': self.username, 'password': self.password })
self.assertRedirects(response, '/')
response = self.client.get(reverse('infrastructure_type_view', args=[self.type.id]))
self.assertEquals(response.status_code, 200)
def test_infrastructure_type_edit(self):
"Test index page with login at /infrastructure/type/edit/<type_id>"
response = self.client.post('/accounts/login',
{'username': self.username, 'password': self.password })
self.assertRedirects(response, '/')
response = self.client.get(reverse('infrastructure_type_edit', args=[self.type.id]))
self.assertEquals(response.status_code, 200)
def test_infrastructure_type_delete(self):
"Test index page with login at /infrastructure/type/delete/<type_id>"
response = self.client.post('/accounts/login',
{'username': self.username, 'password': self.password })
self.assertRedirects(response, '/')
response = self.client.get(reverse('infrastructure_type_delete', args=[self.type.id]))
self.assertEquals(response.status_code, 200)
# Field
def test_infrastructure_field_add(self):
"Test index page with login at /infrastructure/field/add/"
response = self.client.post('/accounts/login',
{'username': self.username, 'password': self.password })
self.assertRedirects(response, '/')
response = self.client.get(reverse('infrastructure_field_add'))
self.assertEquals(response.status_code, 200)
def test_infrastructure_field_view(self):
"Test index page with login at /infrastructure/field/view/<field_id>"
response = self.client.post('/accounts/login',
{'username': self.username, 'password': self.password })
self.assertRedirects(response, '/')
response = self.client.get(reverse('infrastructure_field_view', args=[self.field.id]))
self.assertEquals(response.status_code, 200)
def test_infrastructure_field_edit(self):
"Test index page with login at /infrastructure/field/edit/<field_id>"
response = self.client.post('/accounts/login',
{'username': self.username, 'password': self.password })
self.assertRedirects(response, '/')
response = self.client.get(reverse('infrastructure_field_edit', args=[self.field.id]))
self.assertEquals(response.status_code, 200)
def test_infrastructure_field_del(self):
"Test index page with login at /infrastructure/field/delete/<field_id>"
response = self.client.post('/accounts/login',
{'username': self.username, 'password': self.password })
self.assertRedirects(response, '/')
response = self.client.get(reverse('infrastructure_field_delete', args=[self.field.id]))
self.assertEquals(response.status_code, 200)
# Status
def test_infrastructure_status_add(self):
"Test index page with login at /infrastructure/status/add/"
response = self.client.post('/accounts/login',
{'username': self.username, 'password': self.password })
self.assertRedirects(response, '/')
response = self.client.get(reverse('infrastructure_status_add'))
self.assertEquals(response.status_code, 200)
def test_infrastructure_status_view(self):
"Test index page with login at /infrastructure/status/view/<status_id>"
response = self.client.post('/accounts/login',
{'username': self.username, 'password': self.password })
self.assertRedirects(response, '/')
response = self.client.get(reverse('infrastructure_status_view', args=[self.status.id]))
self.assertEquals(response.status_code, 200)
def test_infrastructure_status_edit(self):
"Test index page with login at /infrastructure/status/edit/<status_id>"
response = self.client.post('/accounts/login',
{'username': self.username, 'password': self.password })
self.assertRedirects(response, '/')
response = self.client.get(reverse('infrastructure_status_edit', args=[self.status.id]))
self.assertEquals(response.status_code, 200)
def test_infrastructure_status_del(self):
"Test index page with login at /infrastructure/status/delete/<status_id>"
response = self.client.post('/accounts/login',
{'username': self.username, 'password': self.password })
self.assertRedirects(response, '/')
response = self.client.get(reverse('infrastructure_status_delete', args=[self.status.id]))
self.assertEquals(response.status_code, 200)
# Item
def test_infrastructure_item_add(self):
"Test index page with login at /infrastructure/item/add/"
response = self.client.post('/accounts/login',
{'username': self.username, 'password': self.password })
self.assertRedirects(response, '/')
response = self.client.get(reverse('infrastructure_item_add'))
self.assertEquals(response.status_code, 200)
def test_infr_item_add_typed(self):
"Test index page with login at /infrastructure/item/add/<type_id>"
response = self.client.post('/accounts/login',
{'username': self.username, 'password': self.password })
self.assertRedirects(response, '/')
response = self.client.get(reverse('infrastructure_item_add_typed', args=[self.type.id]))
self.assertEquals(response.status_code, 200)
def test_infrastructure_item_view(self):
"Test index page with login at /infrastructure/item/view/<item_id>"
response = self.client.post('/accounts/login',
{'username': self.username, 'password': self.password })
self.assertRedirects(response, '/')
response = self.client.get(reverse('infrastructure_item_view', args=[self.item.id]))
self.assertEquals(response.status_code, 200)
def test_infrastructure_item_edit(self):
"Test index page with login at /infrastructure/item/edit/<item_id>"
response = self.client.post('/accounts/login',
{'username': self.username, 'password': self.password })
self.assertRedirects(response, '/')
response = self.client.get(reverse('infrastructure_item_edit', args=[self.item.id]))
self.assertEquals(response.status_code, 200)
def test_infrastructure_item_del(self):
"Test index page with login at /infrastructure/item/delete/<item_id>"
response = self.client.post('/accounts/login',
{'username': self.username, 'password': self.password })
self.assertRedirects(response, '/')
response = self.client.get(reverse('infrastructure_item_delete', args=[self.item.id]))
self.assertEquals(response.status_code, 200)
# Service Record
def test_infr_service_record_index(self):
"Test index page with login at /infrastructure/service_record/index/"
response = self.client.post('/accounts/login',
{'username': self.username, 'password': self.password })
self.assertRedirects(response, '/')
response = self.client.get(reverse('infrastructure_service_record_index'))
self.assertEquals(response.status_code, 200)
def test_infr_service_record_add(self):
"Test index page with login at /infrastructure/service_record/add/"
response = self.client.post('/accounts/login',
{'username': self.username, 'password': self.password })
self.assertRedirects(response, '/')
response = self.client.get(reverse('infrastructure_service_record_add'))
self.assertEquals(response.status_code, 200)
def test_infr_service_record_view(self):
"Test index page with login at /infrastructure/service_record/view/<service_record_id>"
response = self.client.post('/accounts/login',
{'username': self.username, 'password': self.password })
self.assertRedirects(response, '/')
response = self.client.get(reverse('infrastructure_service_record_view', args=[self.servicing.id]))
self.assertEquals(response.status_code, 200)
def test_infr_service_record_edit(self):
"Test index page with login at /infrastructure/service_record/edit/<service_record_id>"
response = self.client.post('/accounts/login',
{'username': self.username, 'password': self.password })
self.assertRedirects(response, '/')
response = self.client.get(reverse('infrastructure_service_record_edit', args=[self.servicing.id]))
self.assertEquals(response.status_code, 200)
def test_infr_service_record_delete(self):
"Test index page with login at /infrastructure/service_record/delete/<service_record_id>"
response = self.client.post('/accounts/login',
{'username': self.username, 'password': self.password })
self.assertRedirects(response, '/')
response = self.client.get(reverse('infrastructure_service_record_delete', args=[self.servicing.id]))
self.assertEquals(response.status_code, 200)
######################################
# Testing views when user is not logged in
######################################
def test_index(self):
"Testing /infrastructure/"
response = self.client.get('/infrastructure/')
# Redirects as unauthenticated
self.assertRedirects(response, reverse('user_login'))
def test_index_infrastructure_out(self):
"Testing /infrastructure/index/"
response = self.client.get(reverse('infrastructure_index'))
self.assertRedirects(response, reverse('user_login'))
def test_infrastructure_index_owned_out(self):
"Testing /infrastructure/owned/"
response = self.client.get(reverse('infrastructure_index_owned'))
self.assertRedirects(response, reverse('user_login'))
# Type
def test_infrastructure_type_add_out(self):
"Testing /infrastructure/type/add/"
response = self.client.get(reverse('infrastructure_type_add'))
self.assertRedirects(response, reverse('user_login'))
def test_infrastructure_type_view_out(self):
"Testing /infrastructure/type/view/<type_id>"
response = self.client.get(reverse('infrastructure_type_view', args=[self.type.id]))
self.assertRedirects(response, reverse('user_login'))
def test_infrastructure_type_edit_out(self):
"Testing /infrastructure/type/edit/<type_id>"
response = self.client.get(reverse('infrastructure_type_edit', args=[self.type.id]))
self.assertRedirects(response, reverse('user_login'))
def test_infrastructure_type_delete_out(self):
"Testing /infrastructure/type/delete/<type_id>"
response = self.client.get(reverse('infrastructure_type_delete', args=[self.type.id]))
self.assertRedirects(response, reverse('user_login'))
# Field
def test_infrastructure_field_add_out(self):
"Testing /infrastructure/field/add/"
response = self.client.get(reverse('infrastructure_field_add'))
self.assertRedirects(response, reverse('user_login'))
def test_infrastructure_field_view_out(self):
"Testing /infrastructure/field/view/<field_id>"
response = self.client.get(reverse('infrastructure_field_view', args=[self.field.id]))
self.assertRedirects(response, reverse('user_login'))
def test_infrastructure_field_edit_out(self):
"Testing /infrastructure/field/edit/<field_id>"
response = self.client.get(reverse('infrastructure_field_edit', args=[self.field.id]))
self.assertRedirects(response, reverse('user_login'))
def test_infrastructure_field_del_out(self):
"Testing /infrastructure/field/delete/<field_id>"
response = self.client.get(reverse('infrastructure_field_delete', args=[self.field.id]))
self.assertRedirects(response, reverse('user_login'))
# Status
def test_infrastructure_status_add_out(self):
"Testing /infrastructure/status/add/"
response = self.client.get(reverse('infrastructure_status_add'))
self.assertRedirects(response, reverse('user_login'))
def test_infrastructure_status_view_out(self):
"Testing /infrastructure/status/view/<status_id>"
response = self.client.get(reverse('infrastructure_status_view', args=[self.status.id]))
self.assertRedirects(response, reverse('user_login'))
def test_infrastructure_status_edit_out(self):
"Testing /infrastructure/status/edit/<status_id>"
response = self.client.get(reverse('infrastructure_status_edit', args=[self.status.id]))
self.assertRedirects(response, reverse('user_login'))
def test_infrastructure_status_del_out(self):
"Testing /infrastructure/status/delete/<status_id>"
response = self.client.get(reverse('infrastructure_status_delete', args=[self.status.id]))
self.assertRedirects(response, reverse('user_login'))
# Item
def test_infrastructure_item_add_out(self):
"Testing /infrastructure/item/add/"
response = self.client.get(reverse('infrastructure_item_add'))
self.assertRedirects(response, reverse('user_login'))
def test_infr_item_add_typed_out(self):
"Testing /infrastructure/item/add/<type_id>"
response = self.client.get(reverse('infrastructure_item_add_typed', args=[self.type.id]))
self.assertRedirects(response, reverse('user_login'))
def test_infrastructure_item_view_out(self):
"Testing /infrastructure/item/view/<item_id>"
response = self.client.get(reverse('infrastructure_item_view', args=[self.item.id]))
self.assertRedirects(response, reverse('user_login'))
def test_infrastructure_item_edit_out(self):
"Testing /infrastructure/item/edit/<item_id>"
response = self.client.get(reverse('infrastructure_item_edit', args=[self.item.id]))
self.assertRedirects(response, reverse('user_login'))
def test_infrastructure_item_del_out(self):
"Testing /infrastructure/item/delete/<item_id>"
response = self.client.get(reverse('infrastructure_item_delete', args=[self.item.id]))
self.assertRedirects(response, reverse('user_login'))
# Service Record
def test_infr_service_record_index_out(self):
"Testing /infrastructure/service_record/index/"
response = self.client.get(reverse('infrastructure_service_record_index'))
self.assertRedirects(response, reverse('user_login'))
def test_infr_service_record_add_out(self):
"Testing /infrastructure/service_record/add/"
response = self.client.get(reverse('infrastructure_service_record_add'))
self.assertRedirects(response, reverse('user_login'))
def test_infr_service_record_view_out(self):
"Testing /infrastructure/service_record/view/<service_record_id>"
response = self.client.get(reverse('infrastructure_service_record_view', args=[self.servicing.id]))
self.assertRedirects(response, reverse('user_login'))
def test_infr_service_record_edit_out(self):
"Testing /infrastructure/service_record/edit/<service_record_id>"
response = self.client.get(reverse('infrastructure_service_record_edit', args=[self.servicing.id]))
self.assertRedirects(response, reverse('user_login'))
def test_infr_service_record_delete_out(self):
"Testing /infrastructure/service_record/delete/<service_record_id>"
response = self.client.get(reverse('infrastructure_service_record_delete', args=[self.servicing.id]))
self.assertRedirects(response, reverse('user_login'))
class EventsViewsTest(TestCase):
"Events functional tests for api"
username = "******"
password = "******"
prepared = False
authentication_headers = {"CONTENT_TYPE": "application/json",
"HTTP_AUTHORIZATION": "Basic YXBpX3Rlc3Q6YXBpX3Bhc3N3b3Jk"}
content_type = 'application/json'
def setUp(self):
"Initial Setup"
if not self.prepared:
# Clean up first
Object.objects.all().delete()
# Create objects
try:
self.group = Group.objects.get(name='test')
except Group.DoesNotExist:
Group.objects.all().delete()
self.group = Group(name='test')
self.group.save()
try:
self.user = DjangoUser.objects.get(username=self.username)
self.user.set_password(self.password)
try:
self.profile = self.user.get_profile()
except Exception:
User.objects.all().delete()
self.user = DjangoUser(username=self.username, password='')
self.user.set_password(self.password)
self.user.save()
except DjangoUser.DoesNotExist:
User.objects.all().delete()
self.user = DjangoUser(username=self.username, password='')
self.user.set_password(self.password)
self.user.save()
try:
perspective = Perspective.objects.get(name='default')
except Perspective.DoesNotExist:
Perspective.objects.all().delete()
perspective = Perspective(name='default')
perspective.set_default_user()
perspective.save()
ModuleSetting.set('default_perspective', perspective.id)
self.event = Event(name='TestStatus', end=datetime.now())
self.event.set_default_user()
self.event.save()
self.client = Client()
self.prepared = True
def test_unauthenticated_access(self):
"Test index page at /api/calendar/events"
response = self.client.get('/api/calendar/events')
# Redirects as unauthenticated
self.assertEquals(response.status_code, 401)
def test_get_events_list(self):
""" Test index page api/infrastructure/types """
response = self.client.get(
path=reverse('api_events'), **self.authentication_headers)
self.assertEquals(response.status_code, 200)
def test_get_field(self):
response = self.client.get(path=reverse(
'api_events', kwargs={'object_ptr': self.event.id}), **self.authentication_headers)
self.assertEquals(response.status_code, 200)
def test_update_field(self):
updates = {"name": "Api_name", "details": "Api details",
"start": "2011-03-01 01:12:09", "end": "2011-03-09 13:05:09"}
response = self.client.put(path=reverse('api_events', kwargs={'object_ptr': self.event.id}),
content_type=self.content_type, data=json.dumps(updates), **self.authentication_headers)
self.assertEquals(response.status_code, 200)
data = json.loads(response.content)
self.assertEquals(data['name'], updates['name'])
self.assertEquals(data['details'], updates['details'])
self.assertEquals(data['start'], updates['start'])
self.assertEquals(data['end'], updates['end'])
def setUp(self):
"Initial Setup"
if not self.prepared:
# Clean up first
Object.objects.all().delete()
User.objects.all().delete()
# Create objects
try:
self.group = Group.objects.get(name="test")
except Group.DoesNotExist:
Group.objects.all().delete()
self.group = Group(name="test")
self.group.save()
try:
self.user = DjangoUser.objects.get(username=self.username)
self.user.set_password(self.password)
try:
self.profile = self.user.get_profile()
except Exception:
User.objects.all().delete()
self.user = DjangoUser(username=self.username, password="")
self.user.set_password(self.password)
self.user.save()
except DjangoUser.DoesNotExist:
User.objects.all().delete()
self.user = DjangoUser(username=self.username, password="")
self.user.set_password(self.password)
self.user.save()
try:
perspective = Perspective.objects.get(name="default")
except Perspective.DoesNotExist:
Perspective.objects.all().delete()
perspective = Perspective(name="default")
perspective.set_user(self.user.get_profile())
perspective.save()
ModuleSetting.set("default_perspective", perspective.id)
self.contact_type = ContactType(name="test")
self.contact_type.set_default_user()
self.contact_type.save()
self.contact = Contact(name="test", contact_type=self.contact_type)
self.contact.set_default_user()
self.contact.save()
self.status = TicketStatus(name="TestStatus")
self.status.set_default_user()
self.status.save()
self.queue = TicketQueue(name="TestQueue", default_ticket_status=self.status)
self.queue.set_default_user()
self.queue.save()
self.ticket = Ticket(name="TestTicket", status=self.status, queue=self.queue)
self.ticket.set_default_user()
self.ticket.save()
self.agent = ServiceAgent(
related_user=self.user.get_profile(), available_from=datetime.time(9), available_to=datetime.time(17)
)
self.agent.set_default_user()
self.agent.save()
self.service = Service(name="test")
self.service.set_default_user()
self.service.save()
self.sla = ServiceLevelAgreement(
name="test", service=self.service, client=self.contact, provider=self.contact
)
self.sla.set_default_user()
self.sla.save()
self.client = Client()
self.prepared = True
def setUp(self):
"Initial Setup"
if not self.prepared:
# Clean up first
Object.objects.all().delete()
# Create objects
try:
self.group = Group.objects.get(name='test')
except Group.DoesNotExist:
Group.objects.all().delete()
self.group = Group(name='test')
self.group.save()
try:
self.user = DjangoUser.objects.get(username=self.username)
self.user.set_password(self.password)
try:
self.profile = self.user.get_profile()
except Exception:
User.objects.all().delete()
self.user = DjangoUser(username=self.username, password='')
self.user.set_password(self.password)
self.user.save()
except DjangoUser.DoesNotExist:
User.objects.all().delete()
self.user = DjangoUser(username=self.username, password='')
self.user.set_password(self.password)
self.user.save()
try:
perspective = Perspective.objects.get(name='default')
except Perspective.DoesNotExist:
Perspective.objects.all().delete()
perspective = Perspective(name='default')
perspective.set_default_user()
perspective.save()
ModuleSetting.set('default_perspective', perspective.id)
self.contact_type = ContactType(name='test')
self.contact_type.set_default_user()
self.contact_type.save()
self.contact = Contact(name='test', contact_type=self.contact_type)
self.contact.set_default_user()
self.contact.save()
self.user_contact = Contact(name='test',
related_user=self.user.get_profile(),
contact_type=self.contact_type)
self.user_contact.set_user(self.user)
self.user_contact.save()
self.stream = MessageStream(name='test')
self.stream.set_default_user()
self.stream.save()
self.mlist = MailingList(name='test', from_contact=self.contact)
self.mlist.set_default_user()
self.mlist.save()
self.message = Message(title='test',
body='test',
author=self.contact,
stream=self.stream)
self.message.set_default_user()
self.message.save()
self.client = Client()
self.prepared = True
def setUp(self):
"Initial Setup"
if not self.prepared:
# Clean up first
Object.objects.all().delete()
# Create objects
try:
self.group = Group.objects.get(name="test")
except Group.DoesNotExist:
Group.objects.all().delete()
self.group = Group(name="test")
self.group.save()
try:
self.user = DjangoUser.objects.get(username=self.username)
self.user.set_password(self.password)
try:
self.profile = self.user.get_profile()
except Exception:
User.objects.all().delete()
self.user = DjangoUser(username=self.username, password="")
self.user.set_password(self.password)
self.user.save()
except DjangoUser.DoesNotExist:
User.objects.all().delete()
self.user = DjangoUser(username=self.username, password="")
self.user.set_password(self.password)
self.user.save()
try:
perspective = Perspective.objects.get(name="default")
except Perspective.DoesNotExist:
Perspective.objects.all().delete()
perspective = Perspective(name="default")
perspective.set_default_user()
perspective.save()
ModuleSetting.set("default_perspective", perspective.id)
self.type = ItemType(name="test")
self.type.set_default_user()
self.type.save()
self.status = ItemStatus(name="test")
self.status.set_default_user()
self.status.save()
self.field = ItemField(name="test", label="test", field_type="text")
self.field.set_default_user()
self.field.save()
self.item = Item(name="test", item_type=self.type, status=self.status)
self.item.set_default_user()
self.item.save()
self.value = ItemValue(field=self.field, item=self.item)
self.value.save()
self.servicing = ItemServicing(name="test")
self.servicing.set_default_user()
self.servicing.save()
self.client = Client()
self.prepared = True
class SalesViewsTest(TestCase):
"Sales functional tests for views"
username = "******"
password = "******"
prepared = False
def setUp(self):
"Initial Setup"
if not self.prepared:
# Clean up first
Object.objects.all().delete()
User.objects.all().delete()
# Create objects
try:
self.group = Group.objects.get(name='test')
except Group.DoesNotExist:
Group.objects.all().delete()
self.group = Group(name='test')
self.group.save()
try:
self.user = DjangoUser.objects.get(username=self.username)
self.user.set_password(self.password)
try:
self.profile = self.user.get_profile()
except Exception:
User.objects.all().delete()
self.user = DjangoUser(username=self.username, password='')
self.user.set_password(self.password)
self.user.save()
except DjangoUser.DoesNotExist:
User.objects.all().delete()
self.user = DjangoUser(username=self.username, password='')
self.user.set_password(self.password)
self.user.save()
try:
perspective = Perspective.objects.get(name='default')
except Perspective.DoesNotExist:
Perspective.objects.all().delete()
perspective = Perspective(name='default')
perspective.set_default_user()
perspective.save()
ModuleSetting.set('default_perspective', perspective.id)
self.contact_type = ContactType()
self.contact_type.slug = 'machine'
self.contact_type.name = 'machine'
self.contact_type.save()
self.contact = Contact()
self.contact.contact_type = self.contact_type
self.contact.set_default_user()
self.contact.save()
self.assertNotEquals(self.contact.id, None)
self.status = SaleStatus()
self.status.set_default_user()
self.status.save()
self.assertNotEquals(self.status.id, None)
self.currency = Currency(code="GBP",
name="Pounds",
symbol="L",
is_default=True)
self.currency.save()
self.source = SaleSource()
self.source.set_default_user()
self.source.save()
self.assertNotEquals(self.source.id, None)
self.product = Product(name="Test")
self.product.product_type = 'service'
self.product.active = True
self.product.sell_price = 10
self.product.buy_price = 100
self.product.set_default_user()
self.product.save()
self.assertNotEquals(self.product.id, None)
self.subscription = Subscription()
self.subscription.client = self.contact
self.subscription.set_default_user()
self.subscription.save()
self.assertNotEquals(self.subscription.id, None)
self.lead = Lead()
self.lead.contact_method = 'email'
self.lead.status = self.status
self.lead.contact = self.contact
self.lead.set_default_user()
self.lead.save()
self.assertNotEquals(self.lead.id, None)
self.opportunity = Opportunity()
self.opportunity.lead = self.lead
self.opportunity.contact = self.contact
self.opportunity.status = self.status
self.opportunity.amount = 100
self.opportunity.amount_currency = self.currency
self.opportunity.amount_display = 120
self.opportunity.set_default_user()
self.opportunity.save()
self.assertNotEquals(self.opportunity.id, None)
self.order = SaleOrder(reference="Test")
self.order.opportunity = self.opportunity
self.order.status = self.status
self.order.source = self.source
self.order.currency = self.currency
self.order.total = 0
self.order.total_display = 0
self.order.set_default_user()
self.order.save()
self.assertNotEquals(self.order.id, None)
self.ordered_product = OrderedProduct()
self.ordered_product.product = self.product
self.ordered_product.order = self.order
self.ordered_product.rate = 0
self.ordered_product.subscription = self.subscription
self.ordered_product.set_default_user()
self.ordered_product.save()
self.assertNotEquals(self.ordered_product.id, None)
self.client = Client()
self.prepared = True
######################################
# Testing views when user is logged in
######################################
def test_index(self):
"Test page with login at /sales/index"
response = self.client.post('/accounts/login',
{'username': self.username, 'password': self.password })
self.assertRedirects(response, '/')
response = self.client.get(reverse('sales_index'))
self.assertEquals(response.status_code, 200)
def test_index_open(self):
"Test page with login at /sales/open"
response = self.client.post('/accounts/login',
{'username': self.username, 'password': self.password })
self.assertRedirects(response, '/')
response = self.client.get(reverse('sales_index_open'))
self.assertEquals(response.status_code, 200)
def test_index_assigned(self):
"Test page with login at /sales/index/assigned"
response = self.client.post('/accounts/login',
{'username': self.username, 'password': self.password })
self.assertRedirects(response, '/')
response = self.client.get(reverse('sales_index_assigned'))
self.assertEquals(response.status_code, 200)
# Orders
def test_order_add(self):
"Test page with login at /sales/order/add"
response = self.client.post('/accounts/login',
{'username': self.username, 'password': self.password })
self.assertRedirects(response, '/')
response = self.client.get(reverse('sales_order_add'))
self.assertEquals(response.status_code, 200)
def test_order_add_lead(self):
"Test page with login at /sales/order/add/lead/"
response = self.client.post('/accounts/login',
{'username': self.username, 'password': self.password })
self.assertRedirects(response, '/')
response = self.client.get(reverse('sales_order_add_with_lead', args=[self.lead.id]))
self.assertEquals(response.status_code, 200)
def test_order_add_opportunity(self):
"Test page with login at /sales/order/add/opportunity/"
response = self.client.post('/accounts/login',
{'username': self.username, 'password': self.password })
self.assertRedirects(response, '/')
response = self.client.get(reverse('sales_order_add_with_opportunity', args=[self.opportunity.id]))
self.assertEquals(response.status_code, 200)
def test_order_edit(self):
"Test page with login at /sales/order/edit/"
response = self.client.post('/accounts/login',
{'username': self.username, 'password': self.password })
self.assertRedirects(response, '/')
response = self.client.get(reverse('sales_order_edit', args=[self.order.id]))
self.assertEquals(response.status_code, 200)
def test_order_view(self):
"Test page with login at /sales/order/view/"
response = self.client.post('/accounts/login',
{'username': self.username, 'password': self.password })
self.assertRedirects(response, '/')
response = self.client.get(reverse('sales_order_view', args=[self.order.id]))
self.assertEquals(response.status_code, 200)
def test_order_delete(self):
"Test page with login at /sales/order/delete/"
response = self.client.post('/accounts/login',
{'username': self.username, 'password': self.password })
self.assertRedirects(response, '/')
response = self.client.get(reverse('sales_order_delete', args=[self.order.id]))
self.assertEquals(response.status_code, 200)
def test_order_invoice_view(self):
"Test page with login at /sales/order/invoice/"
response = self.client.post('/accounts/login',
{'username': self.username, 'password': self.password })
self.assertRedirects(response, '/')
response = self.client.get(reverse('sales_order_invoice_view', args=[self.order.id]))
self.assertEquals(response.status_code, 200)
# Products
def test_product_index(self):
"Test page with login at /sales/product/index"
response = self.client.post('/accounts/login',
{'username': self.username, 'password': self.password })
self.assertRedirects(response, '/')
response = self.client.get(reverse('sales_product_index'))
self.assertEquals(response.status_code, 200)
def test_product_add(self):
"Test page with login at /sales/product/add/"
response = self.client.post('/accounts/login',
{'username': self.username, 'password': self.password })
self.assertRedirects(response, '/')
response = self.client.get(reverse('sales_product_add'))
self.assertEquals(response.status_code, 200)
def test_product_add_parent(self):
"Test page with login at /sales/product/add"
response = self.client.post('/accounts/login',
{'username': self.username, 'password': self.password })
self.assertRedirects(response, '/')
response = self.client.get(reverse('sales_product_add', args=[self.product.id]))
self.assertEquals(response.status_code, 200)
def test_product_edit(self):
"Test page with login at /sales/product/edit/"
response = self.client.post('/accounts/login',
{'username': self.username, 'password': self.password })
self.assertRedirects(response, '/')
response = self.client.get(reverse('sales_product_edit', args=[self.product.id]))
self.assertEquals(response.status_code, 200)
def test_product_view(self):
"Test page with login at /sales/product/view/"
response = self.client.post('/accounts/login',
{'username': self.username, 'password': self.password })
self.assertRedirects(response, '/')
response = self.client.get(reverse('sales_product_view', args=[self.product.id]))
self.assertEquals(response.status_code, 200)
def test_product_delete(self):
"Test page with login at /sales/product/delete/"
response = self.client.post('/accounts/login',
{'username': self.username, 'password': self.password })
self.assertRedirects(response, '/')
response = self.client.get(reverse('sales_product_delete', args=[self.product.id]))
self.assertEquals(response.status_code, 200)
# Settings
def test_settings_view(self):
"Test page with login at /sales/settings/view"
response = self.client.post('/accounts/login',
{'username': self.username, 'password': self.password })
self.assertRedirects(response, '/')
response = self.client.get(reverse('sales_settings_view'))
self.assertEquals(response.status_code, 200)
def test_settings_edit(self):
"Test page with login at /sales/settings/edit"
response = self.client.post('/accounts/login',
{'username': self.username, 'password': self.password })
self.assertRedirects(response, '/')
response = self.client.get(reverse('sales_settings_edit'))
self.assertEquals(response.status_code, 200)
# Statuses
def test_status_add(self):
"Test page with login at /sales/status/add"
response = self.client.post('/accounts/login',
{'username': self.username, 'password': self.password })
self.assertRedirects(response, '/')
response = self.client.get(reverse('sales_status_add'))
self.assertEquals(response.status_code, 200)
def test_status_edit(self):
"Test page with login at /sales/status/edit/"
response = self.client.post('/accounts/login',
{'username': self.username, 'password': self.password })
self.assertRedirects(response, '/')
response = self.client.get(reverse('sales_status_edit', args=[self.status.id]))
self.assertEquals(response.status_code, 200)
def test_status_view(self):
"Test page with login at /sales/status/view/"
response = self.client.post('/accounts/login',
{'username': self.username, 'password': self.password })
self.assertRedirects(response, '/')
response = self.client.get(reverse('sales_status_view', args=[self.status.id]))
self.assertEquals(response.status_code, 200)
def test_status_delete(self):
"Test page with login at /sales/status/delete/"
response = self.client.post('/accounts/login',
{'username': self.username, 'password': self.password })
self.assertRedirects(response, '/')
response = self.client.get(reverse('sales_status_delete', args=[self.status.id]))
self.assertEquals(response.status_code, 200)
# Subscriptions
def test_subscription_add(self):
"Test page with login at /sales/subscription/add"
response = self.client.post('/accounts/login',
{'username': self.username, 'password': self.password })
self.assertRedirects(response, '/')
response = self.client.get(reverse('sales_subscription_add'))
self.assertEquals(response.status_code, 200)
def test_subscription_add_product(self):
"Test page with login at /sales/subscription/add/"
response = self.client.post('/accounts/login',
{'username': self.username, 'password': self.password })
self.assertRedirects(response, '/')
response = self.client.get(reverse('sales_subscription_add_with_product', args=[self.product.id]))
self.assertEquals(response.status_code, 200)
def test_subscription_edit(self):
"Test page with login at /sales/subscription/edit/"
response = self.client.post('/accounts/login',
{'username': self.username, 'password': self.password })
self.assertRedirects(response, '/')
response = self.client.get(reverse('sales_subscription_edit', args=[self.subscription.id]))
self.assertEquals(response.status_code, 200)
def test_subscription_view(self):
"Test page with login at /sales/subscription/view/"
response = self.client.post('/accounts/login',
{'username': self.username, 'password': self.password })
self.assertRedirects(response, '/')
response = self.client.get(reverse('sales_subscription_view', args=[self.subscription.id]))
self.assertEquals(response.status_code, 200)
def test_subscription_delete(self):
"Test page with login at /sales/subscription/delete/"
response = self.client.post('/accounts/login',
{'username': self.username, 'password': self.password })
self.assertRedirects(response, '/')
response = self.client.get(reverse('sales_subscription_delete', args=[self.subscription.id]))
self.assertEquals(response.status_code, 200)
# Ordered Products
def test_ordered_product_add(self):
"Test page with login at /sales/ordered_product/add/"
response = self.client.post('/accounts/login',
{'username': self.username, 'password': self.password })
self.assertRedirects(response, '/')
response = self.client.get(reverse('sales_ordered_product_add', args=[self.order.id]))
self.assertEquals(response.status_code, 200)
def test_ordered_product_edit(self):
"Test page with login at /sales/ordered_product/edit/"
response = self.client.post('/accounts/login',
{'username': self.username, 'password': self.password })
self.assertRedirects(response, '/')
response = self.client.get(reverse('sales_ordered_product_edit', args=[self.ordered_product.id]))
self.assertEquals(response.status_code, 200)
def test_ordered_product_view(self):
"Test page with login at /sales/ordered_product/view/"
response = self.client.post('/accounts/login',
{'username': self.username, 'password': self.password })
self.assertRedirects(response, '/')
response = self.client.get(reverse('sales_ordered_product_view', args=[self.ordered_product.id]))
self.assertEquals(response.status_code, 200)
def test_ordered_product_delete(self):
"Test page with login at /sales/ordered_product/delete/"
response = self.client.post('/accounts/login',
{'username': self.username, 'password': self.password })
self.assertRedirects(response, '/')
response = self.client.get(reverse('sales_ordered_product_delete', args=[self.ordered_product.id]))
self.assertEquals(response.status_code, 200)
# Sources
def test_source_add(self):
"Test page with login at /sales/source/add"
response = self.client.post('/accounts/login',
{'username': self.username, 'password': self.password })
self.assertRedirects(response, '/')
response = self.client.get(reverse('sales_source_add'))
self.assertEquals(response.status_code, 200)
def test_source_edit(self):
"Test page with login at /sales/source/edit/"
response = self.client.post('/accounts/login',
{'username': self.username, 'password': self.password })
self.assertRedirects(response, '/')
response = self.client.get(reverse('sales_source_edit', args=[self.source.id]))
self.assertEquals(response.status_code, 200)
def test_source_view(self):
"Test page with login at /sales/source/view/"
response = self.client.post('/accounts/login',
{'username': self.username, 'password': self.password })
self.assertRedirects(response, '/')
response = self.client.get(reverse('sales_source_view', args=[self.source.id]))
self.assertEquals(response.status_code, 200)
def test_source_delete(self):
"Test page with login at /sales/source/delete/"
response = self.client.post('/accounts/login',
{'username': self.username, 'password': self.password })
self.assertRedirects(response, '/')
response = self.client.get(reverse('sales_source_delete', args=[self.source.id]))
self.assertEquals(response.status_code, 200)
# Leads
def test_lead_index(self):
"Test page with login at /sales/lead/index"
response = self.client.post('/accounts/login',
{'username': self.username, 'password': self.password })
self.assertRedirects(response, '/')
response = self.client.get(reverse('sales_lead_index'))
self.assertEquals(response.status_code, 200)
def test_lead_index_assigned(self):
"Test page with login at /sales/lead/index/assigned"
response = self.client.post('/accounts/login',
{'username': self.username, 'password': self.password })
self.assertRedirects(response, '/')
response = self.client.get(reverse('sales_lead_index_assigned'))
self.assertEquals(response.status_code, 200)
def test_lead_add(self):
"Test page with login at /sales/lead/add"
response = self.client.post('/accounts/login',
{'username': self.username, 'password': self.password })
self.assertRedirects(response, '/')
response = self.client.get(reverse('sales_lead_add'))
self.assertEquals(response.status_code, 200)
def test_lead_edit(self):
"Test page with login at /sales/lead/edit/"
response = self.client.post('/accounts/login',
{'username': self.username, 'password': self.password })
self.assertRedirects(response, '/')
response = self.client.get(reverse('sales_lead_edit', args=[self.lead.id]))
self.assertEquals(response.status_code, 200)
def test_lead_view(self):
"Test page with login at /sales/lead/view/"
response = self.client.post('/accounts/login',
{'username': self.username, 'password': self.password })
self.assertRedirects(response, '/')
response = self.client.get(reverse('sales_lead_view', args=[self.lead.id]))
self.assertEquals(response.status_code, 200)
def test_lead_delete(self):
"Test page with login at /sales/lead/delete/"
response = self.client.post('/accounts/login',
{'username': self.username, 'password': self.password })
self.assertRedirects(response, '/')
response = self.client.get(reverse('sales_lead_delete', args=[self.lead.id]))
self.assertEquals(response.status_code, 200)
# Opportunities
def test_opportunity_index(self):
"Test page with login at /sales/opportunity/index"
response = self.client.post('/accounts/login',
{'username': self.username, 'password': self.password })
self.assertRedirects(response, '/')
response = self.client.get(reverse('sales_opportunity_index'))
self.assertEquals(response.status_code, 200)
def test_opportunity_index_assigned(self):
"Test page with login at /sales/opportunity/index/assigned"
response = self.client.post('/accounts/login',
{'username': self.username, 'password': self.password })
self.assertRedirects(response, '/')
response = self.client.get(reverse('sales_opportunity_index_assigned'))
self.assertEquals(response.status_code, 200)
def test_opportunity_add(self):
"Test page with login at /sales/opportunity/add"
response = self.client.post('/accounts/login',
{'username': self.username, 'password': self.password })
self.assertRedirects(response, '/')
response = self.client.get(reverse('sales_opportunity_add'))
self.assertEquals(response.status_code, 200)
def test_opportunity_add_lead(self):
"Test page with login at /sales/opportunity/add/lead/"
response = self.client.post('/accounts/login',
{'username': self.username, 'password': self.password })
self.assertRedirects(response, '/')
response = self.client.get(reverse('sales_opportunity_add_with_lead', args=[self.lead.id]))
self.assertEquals(response.status_code, 200)
def test_opportunity_edit(self):
"Test page with login at /sales/opportunity/edit/"
response = self.client.post('/accounts/login',
{'username': self.username, 'password': self.password })
self.assertRedirects(response, '/')
response = self.client.get(reverse('sales_opportunity_edit', args=[self.opportunity.id]))
self.assertEquals(response.status_code, 200)
def test_opportunity_view(self):
"Test page with login at /sales/opportunity/view/"
response = self.client.post('/accounts/login',
{'username': self.username, 'password': self.password })
self.assertRedirects(response, '/')
response = self.client.get(reverse('sales_opportunity_view', args=[self.opportunity.id]))
self.assertEquals(response.status_code, 200)
def test_opportunity_delete(self):
"Test page with login at /sales/opportunity/delete/"
response = self.client.post('/accounts/login',
{'username': self.username, 'password': self.password })
self.assertRedirects(response, '/')
response = self.client.get(reverse('sales_opportunity_delete', args=[self.opportunity.id]))
self.assertEquals(response.status_code, 200)
######################################
# Testing views when user is not logged in
######################################
def test_index_anonymous(self):
"Test index page at /sales/"
response = self.client.get('/sales/')
# Redirects as unauthenticated
self.assertRedirects(response, reverse('user_login'))
def test_index_open_out(self):
"Testing /sales/open"
response = self.client.get(reverse('sales_index_open'))
self.assertRedirects(response, reverse('user_login'))
def test_index_assigned_out(self):
"Testing /sales/index/assigned"
response = self.client.get(reverse('sales_index_assigned'))
self.assertRedirects(response, reverse('user_login'))
# Orders
def test_order_add_out(self):
"Testing /sales/order/add"
response = self.client.get(reverse('sales_order_add'))
self.assertRedirects(response, reverse('user_login'))
def test_order_add_lead_out(self):
"Testing /sales/order/add/lead/"
response = self.client.get(reverse('sales_order_add_with_lead', args=[self.lead.id]))
self.assertRedirects(response, reverse('user_login'))
def test_order_add_opportunity_out(self):
"Testing /sales/order/add/opportunity/"
response = self.client.get(reverse('sales_order_add_with_opportunity', args=[self.opportunity.id]))
self.assertRedirects(response, reverse('user_login'))
def test_order_edit_out(self):
"Testing /sales/order/edit/"
response = self.client.get(reverse('sales_order_edit', args=[self.order.id]))
self.assertRedirects(response, reverse('user_login'))
def test_order_view_out(self):
"Testing /sales/order/view/"
response = self.client.get(reverse('sales_order_view', args=[self.order.id]))
self.assertRedirects(response, reverse('user_login'))
def test_order_delete_out(self):
"Testing /sales/order/delete/"
response = self.client.get(reverse('sales_order_delete', args=[self.order.id]))
self.assertRedirects(response, reverse('user_login'))
def test_order_invoice_view_out(self):
"Testing /sales/order/invoice/"
response = self.client.get(reverse('sales_order_invoice_view', args=[self.order.id]))
self.assertRedirects(response, reverse('user_login'))
# Products
def test_product_index_out(self):
"Testing /sales/product/index"
response = self.client.get(reverse('sales_product_index'))
self.assertRedirects(response, reverse('user_login'))
def test_product_add_out(self):
"Testing /sales/product/add/"
response = self.client.get(reverse('sales_product_add'))
self.assertRedirects(response, reverse('user_login'))
def test_product_add_parent_out(self):
"Testing /sales/product/add"
response = self.client.get(reverse('sales_product_add', args=[self.product.id]))
self.assertRedirects(response, reverse('user_login'))
def test_product_edit_out(self):
"Testing /sales/product/edit/"
response = self.client.get(reverse('sales_product_edit', args=[self.product.id]))
self.assertRedirects(response, reverse('user_login'))
def test_product_view_out(self):
"Testing /sales/product/view/"
response = self.client.get(reverse('sales_product_view', args=[self.product.id]))
self.assertRedirects(response, reverse('user_login'))
def test_product_delete_out(self):
"Testing /sales/product/delete/"
response = self.client.get(reverse('sales_product_delete', args=[self.product.id]))
self.assertRedirects(response, reverse('user_login'))
# Settings
def test_settings_view_out(self):
"Testing /sales/settings/view"
response = self.client.get(reverse('sales_settings_view'))
self.assertRedirects(response, reverse('user_login'))
def test_settings_edit_out(self):
"Testing /sales/settings/edit"
response = self.client.get(reverse('sales_settings_edit'))
self.assertRedirects(response, reverse('user_login'))
# Statuses
def test_status_add_out(self):
"Testing /sales/status/add"
response = self.client.get(reverse('sales_status_add'))
self.assertRedirects(response, reverse('user_login'))
def test_status_edit_out(self):
"Testing /sales/status/edit/"
response = self.client.get(reverse('sales_status_edit', args=[self.status.id]))
self.assertRedirects(response, reverse('user_login'))
def test_status_view_out(self):
"Testing /sales/status/view/"
response = self.client.get(reverse('sales_status_view', args=[self.status.id]))
self.assertRedirects(response, reverse('user_login'))
def test_status_delete_out(self):
"Testing /sales/status/delete/"
response = self.client.get(reverse('sales_status_delete', args=[self.status.id]))
self.assertRedirects(response, reverse('user_login'))
# Subscriptions
def test_subscription_add_out(self):
"Testing /sales/subscription/add"
response = self.client.get(reverse('sales_subscription_add'))
self.assertRedirects(response, reverse('user_login'))
def test_subscription_add_product_out(self):
"Testing /sales/subscription/add/"
response = self.client.get(reverse('sales_subscription_add_with_product', args=[self.product.id]))
self.assertRedirects(response, reverse('user_login'))
def test_subscription_edit_out(self):
"Testing /sales/subscription/edit/"
response = self.client.get(reverse('sales_subscription_edit', args=[self.subscription.id]))
self.assertRedirects(response, reverse('user_login'))
def test_subscription_view_out(self):
"Testing /sales/subscription/view/"
response = self.client.get(reverse('sales_subscription_view', args=[self.subscription.id]))
self.assertRedirects(response, reverse('user_login'))
def test_subscription_delete_out(self):
"Testing /sales/subscription/delete/"
response = self.client.get(reverse('sales_subscription_delete', args=[self.subscription.id]))
self.assertRedirects(response, reverse('user_login'))
# Ordered Products
def test_ordered_product_add_out(self):
"Testing /sales/ordered_product/add/"
response = self.client.get(reverse('sales_ordered_product_add', args=[self.order.id]))
self.assertRedirects(response, reverse('user_login'))
def test_ordered_product_edit_out(self):
"Testing /sales/ordered_product/edit/"
response = self.client.get(reverse('sales_ordered_product_edit', args=[self.ordered_product.id]))
self.assertRedirects(response, reverse('user_login'))
def test_ordered_product_view_out(self):
"Testing /sales/ordered_product/view/"
response = self.client.get(reverse('sales_ordered_product_view', args=[self.ordered_product.id]))
self.assertRedirects(response, reverse('user_login'))
def test_ordered_product_delete_out(self):
"Testing /sales/ordered_product/delete/"
response = self.client.get(reverse('sales_ordered_product_delete', args=[self.ordered_product.id]))
self.assertRedirects(response, reverse('user_login'))
# Sources
def test_source_add_out(self):
"Testing /sales/source/add"
response = self.client.get(reverse('sales_source_add'))
self.assertRedirects(response, reverse('user_login'))
def test_source_edit_out(self):
"Testing /sales/source/edit/"
response = self.client.get(reverse('sales_source_edit', args=[self.source.id]))
self.assertRedirects(response, reverse('user_login'))
def test_source_view_out(self):
"Testing /sales/source/view/"
response = self.client.get(reverse('sales_source_view', args=[self.source.id]))
self.assertRedirects(response, reverse('user_login'))
def test_source_delete_out(self):
"Testing /sales/source/delete/"
response = self.client.get(reverse('sales_source_delete', args=[self.source.id]))
self.assertRedirects(response, reverse('user_login'))
# Leads
def test_lead_index_out(self):
"Testing /sales/lead/index"
response = self.client.get(reverse('sales_lead_index'))
self.assertRedirects(response, reverse('user_login'))
def test_lead_index_assigned_out(self):
"Testing /sales/lead/index/assigned"
response = self.client.get(reverse('sales_lead_index_assigned'))
self.assertRedirects(response, reverse('user_login'))
def test_lead_add_out(self):
"Testing /sales/lead/add"
response = self.client.get(reverse('sales_lead_add'))
self.assertRedirects(response, reverse('user_login'))
def test_lead_edit_out(self):
"Testing /sales/lead/edit/"
response = self.client.get(reverse('sales_lead_edit', args=[self.lead.id]))
self.assertRedirects(response, reverse('user_login'))
def test_lead_view_out(self):
"Testing /sales/lead/view/"
response = self.client.get(reverse('sales_lead_view', args=[self.lead.id]))
self.assertRedirects(response, reverse('user_login'))
def test_lead_delete_out(self):
"Testing /sales/lead/delete/"
response = self.client.get(reverse('sales_lead_delete', args=[self.lead.id]))
self.assertRedirects(response, reverse('user_login'))
# Opportunities
def test_opportunity_index_out(self):
"Testing /sales/opportunity/index/"
response = self.client.get(reverse('sales_opportunity_index'))
self.assertRedirects(response, reverse('user_login'))
def test_opportunity_index_assigned_out(self):
"Testing /sales/opportunity/index/assigned/"
response = self.client.get(reverse('sales_opportunity_index_assigned'))
self.assertRedirects(response, reverse('user_login'))
def test_opportunity_add_out(self):
"Testing /sales/opportunity/add/"
response = self.client.get(reverse('sales_opportunity_add'))
self.assertRedirects(response, reverse('user_login'))
def test_opportunity_add_lead_out(self):
"Testing /sales/opportunity/add/lead/"
response = self.client.get(reverse('sales_opportunity_add_with_lead', args=[self.lead.id]))
self.assertRedirects(response, reverse('user_login'))
def test_opportunity_edit_out(self):
"Testing /sales/opportunity/edit/"
response = self.client.get(reverse('sales_opportunity_edit', args=[self.opportunity.id]))
self.assertRedirects(response, reverse('user_login'))
def test_opportunity_view_out(self):
"Testing /sales/opportunity/view/"
response = self.client.get(reverse('sales_opportunity_view', args=[self.opportunity.id]))
self.assertRedirects(response, reverse('user_login'))
def test_opportunity_delete_out(self):
"Testing /sales/opportunity/delete/"
response = self.client.get(reverse('sales_opportunity_delete', args=[self.opportunity.id]))
self.assertRedirects(response, reverse('user_login'))
class ServicesViewsTest(TestCase):
"Services functional tests for views"
username = "******"
password = "******"
prepared = False
def setUp(self):
"Initial Setup"
if not self.prepared:
# Clean up first
Object.objects.all().delete()
User.objects.all().delete()
# Create objects
try:
self.group = Group.objects.get(name='test')
except Group.DoesNotExist:
Group.objects.all().delete()
self.group = Group(name='test')
self.group.save()
try:
self.user = DjangoUser.objects.get(username=self.username)
self.user.set_password(self.password)
try:
self.profile = self.user.get_profile()
except Exception:
User.objects.all().delete()
self.user = DjangoUser(username=self.username, password='')
self.user.set_password(self.password)
self.user.save()
except DjangoUser.DoesNotExist:
User.objects.all().delete()
self.user = DjangoUser(username=self.username, password='')
self.user.set_password(self.password)
self.user.save()
try:
perspective = Perspective.objects.get(name='default')
except Perspective.DoesNotExist:
Perspective.objects.all().delete()
perspective = Perspective(name='default')
perspective.set_user(self.user.get_profile())
perspective.save()
ModuleSetting.set('default_perspective', perspective.id)
self.contact_type = ContactType(name='test')
self.contact_type.set_default_user()
self.contact_type.save()
self.contact = Contact(name='test', contact_type=self.contact_type)
self.contact.set_default_user()
self.contact.save()
self.status = TicketStatus(name='TestStatus')
self.status.set_default_user()
self.status.save()
self.queue = TicketQueue(name='TestQueue',
default_ticket_status=self.status)
self.queue.set_default_user()
self.queue.save()
self.ticket = Ticket(name='TestTicket',
status=self.status,
queue=self.queue)
self.ticket.set_default_user()
self.ticket.save()
self.agent = ServiceAgent(related_user=self.user.get_profile(),
available_from=datetime.time(9),
available_to=datetime.time(17))
self.agent.set_default_user()
self.agent.save()
self.service = Service(name='test')
self.service.set_default_user()
self.service.save()
self.sla = ServiceLevelAgreement(name='test',
service=self.service,
client=self.contact,
provider=self.contact)
self.sla.set_default_user()
self.sla.save()
self.client = Client()
self.prepared = True
######################################
# Testing views when user is logged in
######################################
def test_index_login(self):
"Test index page with login at /services/"
response = self.client.post('/accounts/login', {
'username': self.username,
'password': self.password
})
self.assertRedirects(response, '/')
response = self.client.get(reverse('services'))
self.assertEquals(response.status_code, 200)
def test_index_owned(self):
"Test index page with login at /services/owned"
response = self.client.post('/accounts/login', {
'username': self.username,
'password': self.password
})
self.assertRedirects(response, '/')
response = self.client.get(reverse('services_index_owned'))
self.assertEquals(response.status_code, 200)
def test_index_assigned(self):
"Test index page with login at /services/assigned"
response = self.client.post('/accounts/login', {
'username': self.username,
'password': self.password
})
self.assertRedirects(response, '/')
response = self.client.get(reverse('services_index_assigned'))
self.assertEquals(response.status_code, 200)
# Queues
def test_queue_add(self):
"Test page with login at /services/queue/add"
response = self.client.post('/accounts/login', {
'username': self.username,
'password': self.password
})
self.assertRedirects(response, '/')
response = self.client.get(reverse('services_queue_add'))
self.assertEquals(response.status_code, 200)
def test_queue_view(self):
"Test page with login at /services/queue/view/<queue_id>"
response = self.client.post('/accounts/login', {
'username': self.username,
'password': self.password
})
self.assertRedirects(response, '/')
response = self.client.get(
reverse('services_queue_view', args=[self.queue.id]))
self.assertEquals(response.status_code, 200)
def test_queue_edit(self):
"Test page with login at /services/queue/edit/<queue_id>"
response = self.client.post('/accounts/login', {
'username': self.username,
'password': self.password
})
self.assertRedirects(response, '/')
response = self.client.get(
reverse('services_queue_edit', args=[self.queue.id]))
self.assertEquals(response.status_code, 200)
def test_queue_delete(self):
"Test page with login at /services/queue/delete/<queue_id>"
response = self.client.post('/accounts/login', {
'username': self.username,
'password': self.password
})
self.assertRedirects(response, '/')
response = self.client.get(
reverse('services_queue_delete', args=[self.queue.id]))
self.assertEquals(response.status_code, 200)
# Statuses
def test_status_view(self):
"Test index page with login at /services/status/view/<status_id>"
response = self.client.post('/accounts/login', {
'username': self.username,
'password': self.password
})
self.assertRedirects(response, '/')
response = self.client.get(
reverse('services_status_view', args=[self.status.id]))
self.assertEquals(response.status_code, 200)
def test_status_edit(self):
"Test index page with login at /services/status/edit/<status_id>"
response = self.client.post('/accounts/login', {
'username': self.username,
'password': self.password
})
self.assertRedirects(response, '/')
response = self.client.get(
reverse('services_status_edit', args=[self.status.id]))
self.assertEquals(response.status_code, 200)
def test_status_delete(self):
"Test index page with login at /services/status/delete/<status_id>"
response = self.client.post('/accounts/login', {
'username': self.username,
'password': self.password
})
self.assertRedirects(response, '/')
response = self.client.get(
reverse('services_status_delete', args=[self.status.id]))
self.assertEquals(response.status_code, 200)
def test_status_add(self):
"Test index page with login at /services/status/add/"
response = self.client.post('/accounts/login', {
'username': self.username,
'password': self.password
})
self.assertRedirects(response, '/')
response = self.client.get(reverse('services_status_add'))
self.assertEquals(response.status_code, 200)
# Tickets
def test_ticket_add(self):
"Test page with login at /services/ticket/add"
response = self.client.post('/accounts/login', {
'username': self.username,
'password': self.password
})
self.assertRedirects(response, '/')
response = self.client.get(reverse('services_ticket_add'))
self.assertEquals(response.status_code, 200)
def test_ticket_add_by_queue(self):
"Test page with login at /services/ticket/add/queue/(?P<queue_id>\d+)"
response = self.client.post('/accounts/login', {
'username': self.username,
'password': self.password
})
self.assertRedirects(response, '/')
response = self.client.get(
reverse('services_ticket_add_by_queue', args=[self.queue.id]))
self.assertEquals(response.status_code, 200)
def test_ticket_view(self):
"Test page with login at /services/ticket/view/<ticket_id>"
response = self.client.post('/accounts/login', {
'username': self.username,
'password': self.password
})
self.assertRedirects(response, '/')
response = self.client.get(
reverse('services_ticket_view', args=[self.ticket.id]))
self.assertEquals(response.status_code, 200)
def test_ticket_edit(self):
"Test page with login at /services/ticket/edit/<ticket_id>"
response = self.client.post('/accounts/login', {
'username': self.username,
'password': self.password
})
self.assertRedirects(response, '/')
response = self.client.get(
reverse('services_ticket_edit', args=[self.ticket.id]))
self.assertEquals(response.status_code, 200)
def test_ticket_delete(self):
"Test page with login at /services/ticket/delete/<ticket_id>"
response = self.client.post('/accounts/login', {
'username': self.username,
'password': self.password
})
self.assertRedirects(response, '/')
response = self.client.get(
reverse('services_ticket_delete', args=[self.ticket.id]))
self.assertEquals(response.status_code, 200)
def test_ticket_set_status(self):
"Test page with login at /services/ticket/set/(?P<ticket_id>\d+)/status/(?P<status_id>\d+)"
response = self.client.post('/accounts/login', {
'username': self.username,
'password': self.password
})
self.assertRedirects(response, '/')
response = self.client.get(
reverse('services_ticket_set_status',
args=[self.ticket.id, self.status.id]))
self.assertEquals(response.status_code, 200)
# Settings
def test_settings_view(self):
"Test page with login at /services/settings/view"
response = self.client.post('/accounts/login', {
'username': self.username,
'password': self.password
})
self.assertRedirects(response, '/')
response = self.client.get(reverse('services_settings_view'))
self.assertEquals(response.status_code, 200)
def test_settings_edit(self):
"Test page with login at /services/settings/edit"
response = self.client.post('/accounts/login', {
'username': self.username,
'password': self.password
})
self.assertRedirects(response, '/')
response = self.client.get(reverse('services_settings_view'))
self.assertEquals(response.status_code, 200)
# Catalogue
def test_service_catalogue(self):
"Test page with login at /services/catalogue"
response = self.client.post('/accounts/login', {
'username': self.username,
'password': self.password
})
self.assertRedirects(response, '/')
response = self.client.get(reverse('services_service_catalogue'))
self.assertEquals(response.status_code, 200)
# Services
def test_service_view(self):
"Test page with login at /services/service/view/<service_id>"
response = self.client.post('/accounts/login', {
'username': self.username,
'password': self.password
})
self.assertRedirects(response, '/')
response = self.client.get(
reverse('services_service_view', args=[self.service.id]))
self.assertEquals(response.status_code, 200)
def test_service_edit(self):
"Test page with login at /services/service/edit/<service_id>"
response = self.client.post('/accounts/login', {
'username': self.username,
'password': self.password
})
self.assertRedirects(response, '/')
response = self.client.get(
reverse('services_service_edit', args=[self.service.id]))
self.assertEquals(response.status_code, 200)
def test_service_delete(self):
"Test page with login at /services/service/delete/<service_id>"
response = self.client.post('/accounts/login', {
'username': self.username,
'password': self.password
})
self.assertRedirects(response, '/')
response = self.client.get(
reverse('services_service_delete', args=[self.service.id]))
self.assertEquals(response.status_code, 200)
def test_service_add(self):
"Test page with login at /services/service/add"
response = self.client.post('/accounts/login', {
'username': self.username,
'password': self.password
})
self.assertRedirects(response, '/')
response = self.client.get(reverse('services_service_add'))
self.assertEquals(response.status_code, 200)
# SLAs
def test_sla_index(self):
"Test page with login at /services/sla"
response = self.client.post('/accounts/login', {
'username': self.username,
'password': self.password
})
self.assertRedirects(response, '/')
response = self.client.get(reverse('services_sla_index'))
self.assertEquals(response.status_code, 200)
def test_sla_view(self):
"Test page with login at /services/sla/view/<sla_id>"
response = self.client.post('/accounts/login', {
'username': self.username,
'password': self.password
})
self.assertRedirects(response, '/')
response = self.client.get(
reverse('services_sla_view', args=[self.sla.id]))
self.assertEquals(response.status_code, 200)
def test_sla_edit(self):
"Test page with login at /services/sla/edit/<sla_id>"
response = self.client.post('/accounts/login', {
'username': self.username,
'password': self.password
})
self.assertRedirects(response, '/')
response = self.client.get(
reverse('services_sla_edit', args=[self.sla.id]))
self.assertEquals(response.status_code, 200)
def test_sla_delete(self):
"Test page with login at /services/sla/delete/<sla_id>"
response = self.client.post('/accounts/login', {
'username': self.username,
'password': self.password
})
self.assertRedirects(response, '/')
response = self.client.get(
reverse('services_sla_delete', args=[self.sla.id]))
self.assertEquals(response.status_code, 200)
def test_sla_add(self):
"Test page with login at /services/sla/add"
response = self.client.post('/accounts/login', {
'username': self.username,
'password': self.password
})
self.assertRedirects(response, '/')
response = self.client.get(reverse('services_sla_index'))
self.assertEquals(response.status_code, 200)
# Agents
def test_agent_index(self):
"Test page with login at /services/agent"
response = self.client.post('/accounts/login', {
'username': self.username,
'password': self.password
})
self.assertRedirects(response, '/')
response = self.client.get(reverse('services_agent_index'))
self.assertEquals(response.status_code, 200)
def test_agent_view(self):
"Test page with login at /services/agent/view/<agent_id>"
response = self.client.post('/accounts/login', {
'username': self.username,
'password': self.password
})
self.assertRedirects(response, '/')
response = self.client.get(
reverse('services_agent_view', args=[self.agent.id]))
self.assertEquals(response.status_code, 200)
def test_agent_edit(self):
"Test page with login at /services/agent/edit/<agent_id>"
response = self.client.post('/accounts/login', {
'username': self.username,
'password': self.password
})
self.assertRedirects(response, '/')
response = self.client.get(
reverse('services_agent_edit', args=[self.agent.id]))
self.assertEquals(response.status_code, 200)
def test_agent_delete(self):
"Test page with login at /services/agent/delete/<agent_id>"
response = self.client.post('/accounts/login', {
'username': self.username,
'password': self.password
})
self.assertRedirects(response, '/')
response = self.client.get(
reverse('services_agent_delete', args=[self.agent.id]))
self.assertEquals(response.status_code, 200)
def test_agent_add(self):
"Test page with login at /services/agent/add"
response = self.client.post('/accounts/login', {
'username': self.username,
'password': self.password
})
self.assertRedirects(response, '/')
response = self.client.get(reverse('services_agent_add'))
self.assertEquals(response.status_code, 200)
######################################
# Testing views when user is not logged in
######################################
def test_index(self):
"Test index page at /services/"
response = self.client.get(reverse('services'))
# Redirects as unauthenticated
self.assertRedirects(response, reverse('user_login'))
def test_index_owned_out(self):
"Testing /services/owned"
response = self.client.get(reverse('services_index_owned'))
self.assertRedirects(response, reverse('user_login'))
def test_index_assigned_out(self):
"Testing /services/assigned"
response = self.client.get(reverse('services_index_assigned'))
self.assertRedirects(response, reverse('user_login'))
# Queues
def test_queue_add_out(self):
"Testing /services/queue/add"
response = self.client.get(reverse('services_queue_add'))
self.assertRedirects(response, reverse('user_login'))
def test_queue_view_out(self):
"Testing /services/queue/view/<queue_id>"
response = self.client.get(
reverse('services_queue_view', args=[self.queue.id]))
self.assertRedirects(response, reverse('user_login'))
def test_queue_edit_out(self):
"Testing /services/queue/edit/<queue_id>"
response = self.client.get(
reverse('services_queue_edit', args=[self.queue.id]))
self.assertRedirects(response, reverse('user_login'))
def test_queue_delete_out(self):
"Testing /services/queue/delete/<queue_id>"
response = self.client.get(
reverse('services_queue_delete', args=[self.queue.id]))
self.assertRedirects(response, reverse('user_login'))
# Statuses
def test_status_view_out(self):
"Testing /services/status/view/<status_id>"
response = self.client.get(
reverse('services_status_view', args=[self.status.id]))
self.assertRedirects(response, reverse('user_login'))
def test_status_edit_out(self):
"Testing /services/status/edit/<status_id>"
response = self.client.get(
reverse('services_status_edit', args=[self.status.id]))
self.assertRedirects(response, reverse('user_login'))
def test_status_delete_out(self):
"Testing /services/status/delete/<status_id>"
response = self.client.get(
reverse('services_status_delete', args=[self.status.id]))
self.assertRedirects(response, reverse('user_login'))
def test_status_add_out(self):
"Testing /services/status/add/"
response = self.client.get(reverse('services_status_add'))
self.assertRedirects(response, reverse('user_login'))
# Tickets
def test_ticket_add_out(self):
"Testing /services/ticket/add"
response = self.client.get(reverse('services_ticket_add'))
self.assertRedirects(response, reverse('user_login'))
def test_ticket_add_by_queue_out(self):
"Testing /services/ticket/add/queue/(?P<queue_id>\d+)"
response = self.client.get(
reverse('services_ticket_add_by_queue', args=[self.queue.id]))
self.assertRedirects(response, reverse('user_login'))
def test_ticket_view_out(self):
"Testing /services/ticket/view/<ticket_id>"
response = self.client.get(
reverse('services_ticket_view', args=[self.ticket.id]))
self.assertRedirects(response, reverse('user_login'))
def test_ticket_edit_out(self):
"Testing /services/ticket/edit/<ticket_id>"
response = self.client.get(
reverse('services_ticket_edit', args=[self.ticket.id]))
self.assertRedirects(response, reverse('user_login'))
def test_ticket_delete_out(self):
"Testing /services/ticket/delete/<ticket_id>"
response = self.client.get(
reverse('services_ticket_delete', args=[self.ticket.id]))
self.assertRedirects(response, reverse('user_login'))
def test_ticket_set_status_out(self):
"Testing /services/ticket/set/(?P<ticket_id>\d+)/status/(?P<status_id>\d+)"
response = self.client.get(
reverse('services_ticket_set_status',
args=[self.ticket.id, self.status.id]))
self.assertRedirects(response, reverse('user_login'))
# Settings
def test_settings_view_out(self):
"Testing /services/settings/view"
response = self.client.get(reverse('services_settings_view'))
self.assertRedirects(response, reverse('user_login'))
def test_settings_edit_out(self):
"Testing /services/settings/edit"
response = self.client.get(reverse('services_settings_view'))
self.assertRedirects(response, reverse('user_login'))
# Catalogue
def test_service_catalogue_out(self):
"Testing /services/catalogue"
response = self.client.get(reverse('services_service_catalogue'))
self.assertRedirects(response, reverse('user_login'))
# Services
def test_service_view_out(self):
"Testing /services/service/view/<service_id>"
response = self.client.get(
reverse('services_service_view', args=[self.service.id]))
self.assertRedirects(response, reverse('user_login'))
def test_service_edit_out(self):
"Testing /services/service/edit/<service_id>"
response = self.client.get(
reverse('services_service_edit', args=[self.service.id]))
self.assertRedirects(response, reverse('user_login'))
def test_service_delete_out(self):
"Testing /services/service/delete/<service_id>"
response = self.client.get(
reverse('services_service_delete', args=[self.service.id]))
self.assertRedirects(response, reverse('user_login'))
def test_service_add_out(self):
"Testing /services/service/add"
response = self.client.get(reverse('services_service_add'))
self.assertRedirects(response, reverse('user_login'))
# SLAs
def test_sla_index_out(self):
"Testing /services/sla"
response = self.client.get(reverse('services_sla_index'))
self.assertRedirects(response, reverse('user_login'))
def test_sla_view_out(self):
"Testing /services/sla/view/<sla_id>"
response = self.client.get(
reverse('services_sla_view', args=[self.sla.id]))
self.assertRedirects(response, reverse('user_login'))
def test_sla_edit_out(self):
"Testing /services/sla/edit/<sla_id>"
response = self.client.get(
reverse('services_sla_edit', args=[self.sla.id]))
self.assertRedirects(response, reverse('user_login'))
def test_sla_delete_out(self):
"Testing /services/sla/delete/<sla_id>"
response = self.client.get(
reverse('services_sla_delete', args=[self.sla.id]))
self.assertRedirects(response, reverse('user_login'))
def test_sla_add_out(self):
"Testing /services/sla/add"
response = self.client.get(reverse('services_sla_index'))
self.assertRedirects(response, reverse('user_login'))
# Agents
def test_agent_index_out(self):
"Testing /services/agent"
response = self.client.get(reverse('services_agent_index'))
self.assertRedirects(response, reverse('user_login'))
def test_agent_view_out(self):
"Testing /services/agent/view/<agent_id>"
response = self.client.get(
reverse('services_agent_view', args=[self.agent.id]))
self.assertRedirects(response, reverse('user_login'))
def test_agent_edit_out(self):
"Testing /services/agent/edit/<agent_id>"
response = self.client.get(
reverse('services_agent_edit', args=[self.agent.id]))
self.assertRedirects(response, reverse('user_login'))
def test_agent_delete_out(self):
"Test page with login at /services/agent/delete/<agent_id>"
response = self.client.get(
reverse('services_agent_delete', args=[self.agent.id]))
self.assertRedirects(response, reverse('user_login'))
def test_agent_add_out(self):
"Test page with login at /services/agent/add"
response = self.client.get(reverse('services_agent_add'))
self.assertRedirects(response, reverse('user_login'))
def setUp(self):
"Initial Setup"
if not self.prepared:
# Clean up first
Object.objects.all().delete()
# Create objects
try:
self.group = Group.objects.get(name='test')
except Group.DoesNotExist:
Group.objects.all().delete()
self.group = Group(name='test')
self.group.save()
try:
self.user = DjangoUser.objects.get(username=self.username)
self.user.set_password(self.password)
try:
self.profile = self.user.get_profile()
except Exception:
User.objects.all().delete()
self.user = DjangoUser(username=self.username, password='')
self.user.set_password(self.password)
self.user.save()
except DjangoUser.DoesNotExist:
User.objects.all().delete()
self.user = DjangoUser(username=self.username, password='')
self.user.set_password(self.password)
self.user.save()
try:
perspective = Perspective.objects.get(name='default')
except Perspective.DoesNotExist:
Perspective.objects.all().delete()
perspective = Perspective(name='default')
perspective.set_default_user()
perspective.save()
ModuleSetting.set('default_perspective', perspective.id)
self.type = ItemType(name='test')
self.type.set_default_user()
self.type.save()
self.status = ItemStatus(name='test')
self.status.set_default_user()
self.status.save()
self.field = ItemField(name='test', label='test', field_type='text')
self.field.set_default_user()
self.field.save()
self.item = Item(name='test', item_type=self.type, status=self.status)
self.item.set_default_user()
self.item.save()
self.value = ItemValue(field=self.field, item=self.item)
self.value.save()
self.servicing = ItemServicing(name='test')
self.servicing.set_default_user()
self.servicing.save()
self.client = Client()
self.prepared = True
class SalesAPITest(TestCase):
"Sales functional tests for views"
username = "******"
password = "******"
prepared = False
authentication_headers = {"CONTENT_TYPE": "application/json",
"HTTP_AUTHORIZATION": "Basic YXBpX3Rlc3Q6YXBpX3Bhc3N3b3Jk"}
content_type = 'application/json'
def setUp(self):
"Initial Setup"
if not self.prepared:
# Clean up first
Object.objects.all().delete()
User.objects.all().delete()
# Create objects
try:
self.group = Group.objects.get(name='test')
except Group.DoesNotExist:
Group.objects.all().delete()
self.group = Group(name='test')
self.group.save()
try:
self.user = DjangoUser.objects.get(username=self.username)
self.user.set_password(self.password)
try:
self.profile = self.user.get_profile()
except Exception:
User.objects.all().delete()
self.user = DjangoUser(username=self.username, password='')
self.user.set_password(self.password)
self.user.save()
except DjangoUser.DoesNotExist:
User.objects.all().delete()
self.user = DjangoUser(username=self.username, password='')
self.user.set_password(self.password)
self.user.save()
try:
perspective = Perspective.objects.get(name='default')
except Perspective.DoesNotExist:
Perspective.objects.all().delete()
perspective = Perspective(name='default')
perspective.set_default_user()
perspective.save()
ModuleSetting.set('default_perspective', perspective.id)
self.contact_type = ContactType()
self.contact_type.slug = 'machine'
self.contact_type.name = 'machine'
self.contact_type.save()
self.contact = Contact()
self.contact.contact_type = self.contact_type
self.contact.set_default_user()
self.contact.save()
self.assertNotEquals(self.contact.id, None)
self.status = SaleStatus()
self.status.active = True
self.status.use_sales = True
self.status.use_leads = True
self.status.use_opportunities = True
self.status.set_default_user()
self.status.save()
self.assertNotEquals(self.status.id, None)
self.currency = Currency(code="GBP",
name="Pounds",
symbol="L",
is_default=True)
self.currency.save()
self.source = SaleSource()
self.source.active = True
self.source.save()
self.source.set_user(self.user)
self.assertNotEquals(self.source.id, None)
self.product = Product(name="Test")
self.product.product_type = 'service'
self.product.active = True
self.product.sell_price = 10
self.product.buy_price = 100
self.product.set_default_user()
self.product.save()
self.assertNotEquals(self.product.id, None)
self.subscription = Subscription()
self.subscription.client = self.contact
self.subscription.set_default_user()
self.subscription.save()
self.assertNotEquals(self.subscription.id, None)
self.lead = Lead()
self.lead.contact_method = 'email'
self.lead.status = self.status
self.lead.contact = self.contact
self.lead.set_default_user()
self.lead.save()
self.assertNotEquals(self.lead.id, None)
self.opportunity = Opportunity()
self.opportunity.lead = self.lead
self.opportunity.contact = self.contact
self.opportunity.status = self.status
self.opportunity.amount = 100
self.opportunity.amount_currency = self.currency
self.opportunity.amount_display = 120
self.opportunity.set_default_user()
self.opportunity.save()
self.assertNotEquals(self.opportunity.id, None)
self.order = SaleOrder(reference="Test")
self.order.opportunity = self.opportunity
self.order.status = self.status
self.order.source = self.source
self.order.currency = self.currency
self.order.total = 0
self.order.total_display = 0
self.order.set_default_user()
self.order.save()
self.assertNotEquals(self.order.id, None)
self.ordered_product = OrderedProduct()
self.ordered_product.product = self.product
self.ordered_product.order = self.order
self.ordered_product.rate = 0
self.ordered_product.subscription = self.subscription
self.ordered_product.set_default_user()
self.ordered_product.save()
self.assertNotEquals(self.ordered_product.id, None)
self.client = Client()
self.prepared = True
def test_unauthenticated_access(self):
"Test index page at /sales/statuses"
response = self.client.get('/api/sales/statuses')
# Redirects as unauthenticated
self.assertEquals(response.status_code, 401)
def test_get_statuses_list(self):
""" Test index page api/sales/status """
response = self.client.get(
path=reverse('api_sales_status'), **self.authentication_headers)
self.assertEquals(response.status_code, 200)
def test_get_status(self):
response = self.client.get(path=reverse('api_sales_status', kwargs={
'object_ptr': self.status.id}), **self.authentication_headers)
self.assertEquals(response.status_code, 200)
def test_update_status(self):
updates = {"name": "Close_API", "active": True, "details": "api test details",
"use_leads": True, "use_opportunities": True, "hidden": False}
response = self.client.put(path=reverse('api_sales_status', kwargs={'object_ptr': self.status.id}),
content_type=self.content_type, data=json.dumps(updates), **self.authentication_headers)
self.assertEquals(response.status_code, 200)
data = json.loads(response.content)
self.assertEquals(data['name'], updates['name'])
self.assertEquals(data['active'], updates['active'])
self.assertEquals(data['details'], updates['details'])
self.assertEquals(data['use_leads'], updates['use_leads'])
self.assertEquals(
data['use_opportunities'], updates['use_opportunities'])
self.assertEquals(data['hidden'], updates['hidden'])
def test_get_products_list(self):
""" Test index page api/sales/products """
response = self.client.get(
path=reverse('api_sales_products'), **self.authentication_headers)
self.assertEquals(response.status_code, 200)
def test_get_product(self):
response = self.client.get(path=reverse('api_sales_products', kwargs={
'object_ptr': self.product.id}), **self.authentication_headers)
self.assertEquals(response.status_code, 200)
def test_update_product(self):
updates = {"name": "API product", "parent": None, "product_type": "service", "code": "api_test_code",
"buy_price": '100.05', "sell_price": '10.5', "active": True, "runout_action": "ignore", "details": "api details"}
response = self.client.put(path=reverse('api_sales_products', kwargs={'object_ptr': self.product.id}),
content_type=self.content_type, data=json.dumps(updates), **self.authentication_headers)
self.assertEquals(response.status_code, 200)
data = json.loads(response.content)
self.assertEquals(data['name'], updates['name'])
self.assertEquals(data['product_type'], updates['product_type'])
self.assertEquals(data['code'], updates['code'])
self.assertEquals(data['buy_price'], updates['buy_price'])
self.assertEquals(data['sell_price'], updates['sell_price'])
self.assertEquals(data['active'], updates['active'])
self.assertEquals(data['runout_action'], updates['runout_action'])
self.assertEquals(data['details'], updates['details'])
def test_get_sources_list(self):
""" Test index page api/sales/sources """
response = self.client.get(
path=reverse('api_sales_sources'), **self.authentication_headers)
self.assertEquals(response.status_code, 200)
def test_get_source(self):
response = self.client.get(path=reverse('api_sales_sources', kwargs={
'object_ptr': self.source.id}), **self.authentication_headers)
self.assertEquals(response.status_code, 200)
def test_update_source(self):
updates = {
"name": "Api source", "active": True, "details": "api details"}
response = self.client.put(path=reverse('api_sales_sources', kwargs={'object_ptr': self.source.id}),
content_type=self.content_type, data=json.dumps(updates), **self.authentication_headers)
self.assertEquals(response.status_code, 200)
data = json.loads(response.content)
self.assertEquals(data['name'], updates['name'])
self.assertEquals(data['active'], updates['active'])
self.assertEquals(data['details'], updates['details'])
#
def test_get_leads_list(self):
""" Test index page api/sales/leads """
response = self.client.get(
path=reverse('api_sales_leads'), **self.authentication_headers)
self.assertEquals(response.status_code, 200)
def test_get_lead(self):
response = self.client.get(path=reverse(
'api_sales_leads', kwargs={'object_ptr': self.lead.id}), **self.authentication_headers)
self.assertEquals(response.status_code, 200)
def test_update_lead(self):
updates = {"status": self.status.id, "contact_method": "email", "contact": self.contact.id,
"products_interested": [self.product.id], "source": self.source.id, 'details': 'Api details'}
response = self.client.put(path=reverse('api_sales_leads', kwargs={'object_ptr': self.lead.id}),
content_type=self.content_type, data=json.dumps(updates), **self.authentication_headers)
self.assertEquals(response.status_code, 200)
data = json.loads(response.content)
self.assertEquals(data['status']['id'], updates['status'])
self.assertEquals(data['contact_method'], updates['contact_method'])
self.assertEquals(data['contact']['id'], updates['contact'])
for i, product in enumerate(data['products_interested']):
self.assertEquals(product['id'], updates['products_interested'][i])
self.assertEquals(data['source']['id'], updates['source'])
self.assertEquals(data['details'], updates['details'])
def test_get_opportunities_list(self):
""" Test index page api/sales/opportunities """
response = self.client.get(
path=reverse('api_sales_opportunities'), **self.authentication_headers)
self.assertEquals(response.status_code, 200)
def test_get_opportunity(self):
response = self.client.get(path=reverse('api_sales_opportunities', kwargs={
'object_ptr': self.opportunity.id}), **self.authentication_headers)
self.assertEquals(response.status_code, 200)
def test_update_opportunity(self):
updates = {"status": self.status.id, "products_interested": [self.product.id], "contact": self.contact.id,
"amount_display": 3000.56, "amount_currency": self.currency.id, "details": "API DETAILS"}
response = self.client.put(path=reverse('api_sales_opportunities', kwargs={'object_ptr': self.opportunity.id}),
content_type=self.content_type, data=json.dumps(updates), **self.authentication_headers)
self.assertEquals(response.status_code, 200)
data = json.loads(response.content)
self.assertEquals(data['status']['id'], updates['status'])
self.assertEquals(data['contact']['id'], updates['contact'])
for i, product in enumerate(data['products_interested']):
self.assertEquals(product['id'], updates['products_interested'][i])
self.assertEquals(
data['amount_currency']['id'], updates['amount_currency'])
self.assertEquals(data['details'], updates['details'])
def test_get_orders_list(self):
""" Test index page api/sales/orders """
response = self.client.get(
path=reverse('api_sales_orders'), **self.authentication_headers)
self.assertEquals(response.status_code, 200)
def test_get_order(self):
response = self.client.get(path=reverse(
'api_sales_orders', kwargs={'object_ptr': self.order.id}), **self.authentication_headers)
self.assertEquals(response.status_code, 200)
def test_update_order(self):
updates = {"datetime": "2011-04-11 12:01:15", "status": self.status.id,
"source": self.source.id, "details": "api details"}
response = self.client.put(path=reverse('api_sales_orders', kwargs={'object_ptr': self.order.id}),
content_type=self.content_type, data=json.dumps(updates), **self.authentication_headers)
self.assertEquals(response.status_code, 200)
data = json.loads(response.content)
self.assertEquals(data['status']['id'], updates['status'])
self.assertEquals(data['source']['id'], updates['source'])
self.assertEquals(data['details'], updates['details'])
def test_get_subscriptions_list(self):
""" Test index page api/sales/subscriptions"""
response = self.client.get(
path=reverse('api_sales_subscriptions'), **self.authentication_headers)
self.assertEquals(response.status_code, 200)
def test_get_subscription(self):
response = self.client.get(path=reverse('api_sales_subscriptions', kwargs={
'object_ptr': self.subscription.id}), **self.authentication_headers)
self.assertEquals(response.status_code, 200)
def test_update_subscription(self):
updates = {"product": self.product.id, "start": "2011-06-30",
"cycle_period": "daily", "active": True, "details": "api details"}
response = self.client.put(path=reverse('api_sales_subscriptions', kwargs={'object_ptr': self.subscription.id}),
content_type=self.content_type, data=json.dumps(updates), **self.authentication_headers)
self.assertEquals(response.status_code, 200)
data = json.loads(response.content)
self.assertEquals(data['product']['id'], updates['product'])
self.assertEquals(data['cycle_period'], updates['cycle_period'])
self.assertEquals(data['active'], updates['active'])
self.assertEquals(data['details'], updates['details'])
def test_get_ordered_product(self):
response = self.client.get(path=reverse('api_sales_ordered_products', kwargs={
'object_ptr': self.ordered_product.id}), **self.authentication_headers)
self.assertEquals(response.status_code, 200)
def test_update_ordered_product(self):
updates = {
"discount": '10.0', "product": self.product.id, "quantity": '10'}
response = self.client.put(path=reverse('api_sales_ordered_products', kwargs={'object_ptr': self.ordered_product.id}),
content_type=self.content_type, data=json.dumps(updates), **self.authentication_headers)
self.assertEquals(response.status_code, 200)
data = json.loads(response.content)
self.assertEquals(data['product']['id'], updates['product'])
self.assertEquals(data['discount'], updates['discount'])
self.assertEquals(data['quantity'], updates['quantity'])
class ServicesViewsTest(TestCase):
"Services functional tests for api"
username = "******"
password = "******"
prepared = False
authentication_headers = {
"CONTENT_TYPE": "application/json",
"HTTP_AUTHORIZATION": "Basic YXBpX3Rlc3Q6YXBpX3Bhc3N3b3Jk",
}
content_type = "application/json"
prepared = False
def setUp(self):
"Initial Setup"
if not self.prepared:
# Clean up first
Object.objects.all().delete()
User.objects.all().delete()
# Create objects
try:
self.group = Group.objects.get(name="test")
except Group.DoesNotExist:
Group.objects.all().delete()
self.group = Group(name="test")
self.group.save()
try:
self.user = DjangoUser.objects.get(username=self.username)
self.user.set_password(self.password)
try:
self.profile = self.user.get_profile()
except Exception:
User.objects.all().delete()
self.user = DjangoUser(username=self.username, password="")
self.user.set_password(self.password)
self.user.save()
except DjangoUser.DoesNotExist:
User.objects.all().delete()
self.user = DjangoUser(username=self.username, password="")
self.user.set_password(self.password)
self.user.save()
try:
perspective = Perspective.objects.get(name="default")
except Perspective.DoesNotExist:
Perspective.objects.all().delete()
perspective = Perspective(name="default")
perspective.set_user(self.user.get_profile())
perspective.save()
ModuleSetting.set("default_perspective", perspective.id)
self.contact_type = ContactType(name="test")
self.contact_type.set_default_user()
self.contact_type.save()
self.contact = Contact(name="test", contact_type=self.contact_type)
self.contact.set_default_user()
self.contact.save()
self.status = TicketStatus(name="TestStatus")
self.status.set_default_user()
self.status.save()
self.queue = TicketQueue(name="TestQueue", default_ticket_status=self.status)
self.queue.set_default_user()
self.queue.save()
self.ticket = Ticket(name="TestTicket", status=self.status, queue=self.queue)
self.ticket.set_default_user()
self.ticket.save()
self.agent = ServiceAgent(
related_user=self.user.get_profile(), available_from=datetime.time(9), available_to=datetime.time(17)
)
self.agent.set_default_user()
self.agent.save()
self.service = Service(name="test")
self.service.set_default_user()
self.service.save()
self.sla = ServiceLevelAgreement(
name="test", service=self.service, client=self.contact, provider=self.contact
)
self.sla.set_default_user()
self.sla.save()
self.client = Client()
self.prepared = True
def test_unauthenticated_access(self):
"Test index page at /api/services/services"
response = self.client.get("/api/services/services")
# Redirects as unauthenticated
self.assertEquals(response.status_code, 401)
def test_get_ticket_statuses_list(self):
""" Test index page api/services/status """
response = self.client.get(path=reverse("api_services_status"), **self.authentication_headers)
self.assertEquals(response.status_code, 200)
def test_get_status(self):
response = self.client.get(
path=reverse("api_services_status", kwargs={"object_ptr": self.status.id}), **self.authentication_headers
)
self.assertEquals(response.status_code, 200)
def test_update_status(self):
updates = {"name": "Api update", "details": "<p>api details</p>"}
response = self.client.put(
path=reverse("api_services_status", kwargs={"object_ptr": self.status.id}),
content_type=self.content_type,
data=json.dumps(updates),
**self.authentication_headers
)
self.assertEquals(response.status_code, 200)
def test_get_services_list(self):
""" Test index page api/services """
response = self.client.get(path=reverse("api_services"), **self.authentication_headers)
self.assertEquals(response.status_code, 200)
def test_get_service(self):
response = self.client.get(
path=reverse("api_services", kwargs={"object_ptr": self.service.id}), **self.authentication_headers
)
self.assertEquals(response.status_code, 200)
def test_update_service(self):
updates = {"name": "Api update", "details": "<p>api details</p>"}
response = self.client.put(
path=reverse("api_services", kwargs={"object_ptr": self.service.id}),
content_type=self.content_type,
data=json.dumps(updates),
**self.authentication_headers
)
self.assertEquals(response.status_code, 200)
def test_get_sla_list(self):
""" Test index page api/services/sla """
response = self.client.get(path=reverse("api_services_sla"), **self.authentication_headers)
self.assertEquals(response.status_code, 200)
def test_get_sla(self):
response = self.client.get(
path=reverse("api_services_sla", kwargs={"object_ptr": self.sla.id}), **self.authentication_headers
)
self.assertEquals(response.status_code, 200)
def test_update_sla(self):
updates = {"name": "Api update", "service": self.service.id, "provider": self.contact.id}
response = self.client.put(
path=reverse("api_services_sla", kwargs={"object_ptr": self.sla.id}),
content_type=self.content_type,
data=json.dumps(updates),
**self.authentication_headers
)
print "content:"
print response.content
self.assertEquals(response.status_code, 200)
def test_get_agents_list(self):
""" Test index page api/services/agents """
response = self.client.get(path=reverse("api_services_agents"), **self.authentication_headers)
self.assertEquals(response.status_code, 200)
def test_get_agent(self):
response = self.client.get(
path=reverse("api_services_agents", kwargs={"object_ptr": self.agent.id}), **self.authentication_headers
)
self.assertEquals(response.status_code, 200)
def test_update_sla(self):
updates = {"activate": True, "related_user": User.objects.all()[0].id}
response = self.client.put(
path=reverse("api_services_agents", kwargs={"object_ptr": self.agent.id}),
content_type=self.content_type,
data=json.dumps(updates),
**self.authentication_headers
)
self.assertEquals(response.status_code, 200)
def test_get_queues_list(self):
""" Test index page api/services/queues """
response = self.client.get(path=reverse("api_services_queues"), **self.authentication_headers)
self.assertEquals(response.status_code, 200)
def test_get_queue(self):
response = self.client.get(
path=reverse("api_services_queues", kwargs={"object_ptr": self.queue.id}), **self.authentication_headers
)
self.assertEquals(response.status_code, 200)
def test_update_queue(self):
updates = {
"name": "Api test",
"default_ticket_priority": 5,
"ticket_code": "api",
"waiting_time": 300,
"default_ticket_status": self.status.id,
}
response = self.client.put(
path=reverse("api_services_queues", kwargs={"object_ptr": self.queue.id}),
content_type=self.content_type,
data=json.dumps(updates),
**self.authentication_headers
)
self.assertEquals(response.status_code, 200)
def test_get_records(self):
""" Test index page api/services/ticket/records/{ticket number} """
response = self.client.get(
path=reverse("api_services_ticket_records", kwargs={"ticket_id": self.ticket.id}),
**self.authentication_headers
)
self.assertEquals(response.status_code, 200)
def test_create_record(self):
new_record = {"body": "api test message", "notify": False}
response = self.client.post(
path=reverse("api_services_ticket_records", kwargs={"ticket_id": self.ticket.id}),
data=json.dumps(new_record),
content_type=self.content_type,
**self.authentication_headers
)
self.assertEquals(response.status_code, 200)
data = json.loads(response.content)
self.assertEquals(new_record["body"], data["body"])
def test_get_tasks_list(self):
""" Test index page api/services/tasks """
response = self.client.get(path=reverse("api_services_tickets"), **self.authentication_headers)
self.assertEquals(response.status_code, 200)
def test_get_ticket(self):
response = self.client.get(
path=reverse("api_services_tickets", kwargs={"object_ptr": self.ticket.id}), **self.authentication_headers
)
self.assertEquals(response.status_code, 200)
def test_update_ticket(self):
updates = {"name": "Api updates", "status": self.status.id, "priority": 3, "urgency": 5}
response = self.client.put(
path=reverse("api_services_tickets", kwargs={"object_ptr": self.ticket.id}),
content_type=self.content_type,
data=json.dumps(updates),
**self.authentication_headers
)
self.assertEquals(response.status_code, 200)
def test_create_ticket(self):
new_ticket = {"name": "Api creates", "status": self.status.id, "priority": 3, "urgency": 5}
response = self.client.post(
path=reverse("api_services_tickets") + "?" + urllib.urlencode({"queue_id": self.queue.id}),
content_type=self.content_type,
data=json.dumps(new_ticket),
**self.authentication_headers
)
self.assertEquals(response.status_code, 200)
data = json.loads(response.content)
self.assertEquals(new_ticket["name"], data["name"])
self.assertEquals(new_ticket["urgency"], data["urgency"])
self.assertEquals(new_ticket["priority"], data["priority"])
self.assertEquals(new_ticket["status"], data["status"]["id"])
def setUp(self):
"Initial Setup"
if not self.prepared:
# Clean up first
Object.objects.all().delete()
User.objects.all().delete()
# Create objects
try:
self.group = Group.objects.get(name='test')
except Group.DoesNotExist:
Group.objects.all().delete()
self.group = Group(name='test')
self.group.save()
try:
self.user = DjangoUser.objects.get(username=self.username)
self.user.set_password(self.password)
try:
self.profile = self.user.get_profile()
except Exception:
User.objects.all().delete()
self.user = DjangoUser(username=self.username, password='')
self.user.set_password(self.password)
self.user.save()
except DjangoUser.DoesNotExist:
User.objects.all().delete()
self.user = DjangoUser(username=self.username, password='')
self.user.set_password(self.password)
self.user.save()
try:
perspective = Perspective.objects.get(name='default')
except Perspective.DoesNotExist:
Perspective.objects.all().delete()
perspective = Perspective(name='default')
perspective.set_default_user()
perspective.save()
ModuleSetting.set('default_perspective', perspective.id)
self.contact_type = ContactType()
self.contact_type.slug = 'machine'
self.contact_type.name = 'machine'
self.contact_type.save()
self.contact = Contact()
self.contact.contact_type = self.contact_type
self.contact.set_default_user()
self.contact.save()
self.assertNotEquals(self.contact.id, None)
self.status = SaleStatus()
self.status.active = True
self.status.use_sales = True
self.status.use_leads = True
self.status.use_opportunities = True
self.status.set_default_user()
self.status.save()
self.assertNotEquals(self.status.id, None)
self.currency = Currency(code="GBP",
name="Pounds",
symbol="L",
is_default=True)
self.currency.save()
self.source = SaleSource()
self.source.active = True
self.source.save()
self.source.set_user(self.user)
self.assertNotEquals(self.source.id, None)
self.product = Product(name="Test")
self.product.product_type = 'service'
self.product.active = True
self.product.sell_price = 10
self.product.buy_price = 100
self.product.set_default_user()
self.product.save()
self.assertNotEquals(self.product.id, None)
self.subscription = Subscription()
self.subscription.client = self.contact
self.subscription.set_default_user()
self.subscription.save()
self.assertNotEquals(self.subscription.id, None)
self.lead = Lead()
self.lead.contact_method = 'email'
self.lead.status = self.status
self.lead.contact = self.contact
self.lead.set_default_user()
self.lead.save()
self.assertNotEquals(self.lead.id, None)
self.opportunity = Opportunity()
self.opportunity.lead = self.lead
self.opportunity.contact = self.contact
self.opportunity.status = self.status
self.opportunity.amount = 100
self.opportunity.amount_currency = self.currency
self.opportunity.amount_display = 120
self.opportunity.set_default_user()
self.opportunity.save()
self.assertNotEquals(self.opportunity.id, None)
self.order = SaleOrder(reference="Test")
self.order.opportunity = self.opportunity
self.order.status = self.status
self.order.source = self.source
self.order.currency = self.currency
self.order.total = 0
self.order.total_display = 0
self.order.set_default_user()
self.order.save()
self.assertNotEquals(self.order.id, None)
self.ordered_product = OrderedProduct()
self.ordered_product.product = self.product
self.ordered_product.order = self.order
self.ordered_product.rate = 0
self.ordered_product.subscription = self.subscription
self.ordered_product.set_default_user()
self.ordered_product.save()
self.assertNotEquals(self.ordered_product.id, None)
self.client = Client()
self.prepared = True
class InfrastructureViewsTest(TestCase):
"Infrastructure functional tests for views"
username = "******"
password = "******"
prepared = False
def setUp(self):
"Initial Setup"
if not self.prepared:
# Clean up first
Object.objects.all().delete()
# Create objects
try:
self.group = Group.objects.get(name="test")
except Group.DoesNotExist:
Group.objects.all().delete()
self.group = Group(name="test")
self.group.save()
try:
self.user = DjangoUser.objects.get(username=self.username)
self.user.set_password(self.password)
try:
self.profile = self.user.get_profile()
except Exception:
User.objects.all().delete()
self.user = DjangoUser(username=self.username, password="")
self.user.set_password(self.password)
self.user.save()
except DjangoUser.DoesNotExist:
User.objects.all().delete()
self.user = DjangoUser(username=self.username, password="")
self.user.set_password(self.password)
self.user.save()
try:
perspective = Perspective.objects.get(name="default")
except Perspective.DoesNotExist:
Perspective.objects.all().delete()
perspective = Perspective(name="default")
perspective.set_default_user()
perspective.save()
ModuleSetting.set("default_perspective", perspective.id)
self.type = ItemType(name="test")
self.type.set_default_user()
self.type.save()
self.status = ItemStatus(name="test")
self.status.set_default_user()
self.status.save()
self.field = ItemField(name="test", label="test", field_type="text")
self.field.set_default_user()
self.field.save()
self.item = Item(name="test", item_type=self.type, status=self.status)
self.item.set_default_user()
self.item.save()
self.value = ItemValue(field=self.field, item=self.item)
self.value.save()
self.servicing = ItemServicing(name="test")
self.servicing.set_default_user()
self.servicing.save()
self.client = Client()
self.prepared = True
######################################
# Testing views when user is logged in
######################################
def test_index_login(self):
"Test index page with login at /infrastructure/"
response = self.client.post("/accounts/login", {"username": self.username, "password": self.password})
self.assertRedirects(response, "/")
response = self.client.get(reverse("infrastructure"))
self.assertEquals(response.status_code, 200)
def test_index_infrastructure_login(self):
"Test index page with login at /infrastructure/index/"
response = self.client.post("/accounts/login", {"username": self.username, "password": self.password})
self.assertRedirects(response, "/")
response = self.client.get(reverse("infrastructure_index"))
self.assertEquals(response.status_code, 200)
def test_infrastructure_index_owned(self):
"Test index page with login at /infrastructure/owned/"
response = self.client.post("/accounts/login", {"username": self.username, "password": self.password})
self.assertRedirects(response, "/")
response = self.client.get(reverse("infrastructure_index_owned"))
self.assertEquals(response.status_code, 200)
# Type
def test_infrastructure_type_add(self):
"Test index page with login at /infrastructure/type/add/"
response = self.client.post("/accounts/login", {"username": self.username, "password": self.password})
self.assertRedirects(response, "/")
response = self.client.get(reverse("infrastructure_type_add"))
self.assertEquals(response.status_code, 200)
def test_infrastructure_type_view(self):
"Test index page with login at /infrastructure/type/view/<type_id>"
response = self.client.post("/accounts/login", {"username": self.username, "password": self.password})
self.assertRedirects(response, "/")
response = self.client.get(reverse("infrastructure_type_view", args=[self.type.id]))
self.assertEquals(response.status_code, 200)
def test_infrastructure_type_edit(self):
"Test index page with login at /infrastructure/type/edit/<type_id>"
response = self.client.post("/accounts/login", {"username": self.username, "password": self.password})
self.assertRedirects(response, "/")
response = self.client.get(reverse("infrastructure_type_edit", args=[self.type.id]))
self.assertEquals(response.status_code, 200)
def test_infrastructure_type_delete(self):
"Test index page with login at /infrastructure/type/delete/<type_id>"
response = self.client.post("/accounts/login", {"username": self.username, "password": self.password})
self.assertRedirects(response, "/")
response = self.client.get(reverse("infrastructure_type_delete", args=[self.type.id]))
self.assertEquals(response.status_code, 200)
# Field
def test_infrastructure_field_add(self):
"Test index page with login at /infrastructure/field/add/"
response = self.client.post("/accounts/login", {"username": self.username, "password": self.password})
self.assertRedirects(response, "/")
response = self.client.get(reverse("infrastructure_field_add"))
self.assertEquals(response.status_code, 200)
def test_infrastructure_field_view(self):
"Test index page with login at /infrastructure/field/view/<field_id>"
response = self.client.post("/accounts/login", {"username": self.username, "password": self.password})
self.assertRedirects(response, "/")
response = self.client.get(reverse("infrastructure_field_view", args=[self.field.id]))
self.assertEquals(response.status_code, 200)
def test_infrastructure_field_edit(self):
"Test index page with login at /infrastructure/field/edit/<field_id>"
response = self.client.post("/accounts/login", {"username": self.username, "password": self.password})
self.assertRedirects(response, "/")
response = self.client.get(reverse("infrastructure_field_edit", args=[self.field.id]))
self.assertEquals(response.status_code, 200)
def test_infrastructure_field_del(self):
"Test index page with login at /infrastructure/field/delete/<field_id>"
response = self.client.post("/accounts/login", {"username": self.username, "password": self.password})
self.assertRedirects(response, "/")
response = self.client.get(reverse("infrastructure_field_delete", args=[self.field.id]))
self.assertEquals(response.status_code, 200)
# Status
def test_infrastructure_status_add(self):
"Test index page with login at /infrastructure/status/add/"
response = self.client.post("/accounts/login", {"username": self.username, "password": self.password})
self.assertRedirects(response, "/")
response = self.client.get(reverse("infrastructure_status_add"))
self.assertEquals(response.status_code, 200)
def test_infrastructure_status_view(self):
"Test index page with login at /infrastructure/status/view/<status_id>"
response = self.client.post("/accounts/login", {"username": self.username, "password": self.password})
self.assertRedirects(response, "/")
response = self.client.get(reverse("infrastructure_status_view", args=[self.status.id]))
self.assertEquals(response.status_code, 200)
def test_infrastructure_status_edit(self):
"Test index page with login at /infrastructure/status/edit/<status_id>"
response = self.client.post("/accounts/login", {"username": self.username, "password": self.password})
self.assertRedirects(response, "/")
response = self.client.get(reverse("infrastructure_status_edit", args=[self.status.id]))
self.assertEquals(response.status_code, 200)
def test_infrastructure_status_del(self):
"Test index page with login at /infrastructure/status/delete/<status_id>"
response = self.client.post("/accounts/login", {"username": self.username, "password": self.password})
self.assertRedirects(response, "/")
response = self.client.get(reverse("infrastructure_status_delete", args=[self.status.id]))
self.assertEquals(response.status_code, 200)
# Item
def test_infrastructure_item_add(self):
"Test index page with login at /infrastructure/item/add/"
response = self.client.post("/accounts/login", {"username": self.username, "password": self.password})
self.assertRedirects(response, "/")
response = self.client.get(reverse("infrastructure_item_add"))
self.assertEquals(response.status_code, 200)
def test_infr_item_add_typed(self):
"Test index page with login at /infrastructure/item/add/<type_id>"
response = self.client.post("/accounts/login", {"username": self.username, "password": self.password})
self.assertRedirects(response, "/")
response = self.client.get(reverse("infrastructure_item_add_typed", args=[self.type.id]))
self.assertEquals(response.status_code, 200)
def test_infrastructure_item_view(self):
"Test index page with login at /infrastructure/item/view/<item_id>"
response = self.client.post("/accounts/login", {"username": self.username, "password": self.password})
self.assertRedirects(response, "/")
response = self.client.get(reverse("infrastructure_item_view", args=[self.item.id]))
self.assertEquals(response.status_code, 200)
def test_infrastructure_item_edit(self):
"Test index page with login at /infrastructure/item/edit/<item_id>"
response = self.client.post("/accounts/login", {"username": self.username, "password": self.password})
self.assertRedirects(response, "/")
response = self.client.get(reverse("infrastructure_item_edit", args=[self.item.id]))
self.assertEquals(response.status_code, 200)
def test_infrastructure_item_del(self):
"Test index page with login at /infrastructure/item/delete/<item_id>"
response = self.client.post("/accounts/login", {"username": self.username, "password": self.password})
self.assertRedirects(response, "/")
response = self.client.get(reverse("infrastructure_item_delete", args=[self.item.id]))
self.assertEquals(response.status_code, 200)
# Service Record
def test_infr_service_record_index(self):
"Test index page with login at /infrastructure/service_record/index/"
response = self.client.post("/accounts/login", {"username": self.username, "password": self.password})
self.assertRedirects(response, "/")
response = self.client.get(reverse("infrastructure_service_record_index"))
self.assertEquals(response.status_code, 200)
def test_infr_service_record_add(self):
"Test index page with login at /infrastructure/service_record/add/"
response = self.client.post("/accounts/login", {"username": self.username, "password": self.password})
self.assertRedirects(response, "/")
response = self.client.get(reverse("infrastructure_service_record_add"))
self.assertEquals(response.status_code, 200)
def test_infr_service_record_view(self):
"Test index page with login at /infrastructure/service_record/view/<service_record_id>"
response = self.client.post("/accounts/login", {"username": self.username, "password": self.password})
self.assertRedirects(response, "/")
response = self.client.get(reverse("infrastructure_service_record_view", args=[self.servicing.id]))
self.assertEquals(response.status_code, 200)
def test_infr_service_record_edit(self):
"Test index page with login at /infrastructure/service_record/edit/<service_record_id>"
response = self.client.post("/accounts/login", {"username": self.username, "password": self.password})
self.assertRedirects(response, "/")
response = self.client.get(reverse("infrastructure_service_record_edit", args=[self.servicing.id]))
self.assertEquals(response.status_code, 200)
def test_infr_service_record_delete(self):
"Test index page with login at /infrastructure/service_record/delete/<service_record_id>"
response = self.client.post("/accounts/login", {"username": self.username, "password": self.password})
self.assertRedirects(response, "/")
response = self.client.get(reverse("infrastructure_service_record_delete", args=[self.servicing.id]))
self.assertEquals(response.status_code, 200)
######################################
# Testing views when user is not logged in
######################################
def test_index(self):
"Testing /infrastructure/"
response = self.client.get("/infrastructure/")
# Redirects as unauthenticated
self.assertRedirects(response, reverse("user_login"))
def test_index_infrastructure_out(self):
"Testing /infrastructure/index/"
response = self.client.get(reverse("infrastructure_index"))
self.assertRedirects(response, reverse("user_login"))
def test_infrastructure_index_owned_out(self):
"Testing /infrastructure/owned/"
response = self.client.get(reverse("infrastructure_index_owned"))
self.assertRedirects(response, reverse("user_login"))
# Type
def test_infrastructure_type_add_out(self):
"Testing /infrastructure/type/add/"
response = self.client.get(reverse("infrastructure_type_add"))
self.assertRedirects(response, reverse("user_login"))
def test_infrastructure_type_view_out(self):
"Testing /infrastructure/type/view/<type_id>"
response = self.client.get(reverse("infrastructure_type_view", args=[self.type.id]))
self.assertRedirects(response, reverse("user_login"))
def test_infrastructure_type_edit_out(self):
"Testing /infrastructure/type/edit/<type_id>"
response = self.client.get(reverse("infrastructure_type_edit", args=[self.type.id]))
self.assertRedirects(response, reverse("user_login"))
def test_infrastructure_type_delete_out(self):
"Testing /infrastructure/type/delete/<type_id>"
response = self.client.get(reverse("infrastructure_type_delete", args=[self.type.id]))
self.assertRedirects(response, reverse("user_login"))
# Field
def test_infrastructure_field_add_out(self):
"Testing /infrastructure/field/add/"
response = self.client.get(reverse("infrastructure_field_add"))
self.assertRedirects(response, reverse("user_login"))
def test_infrastructure_field_view_out(self):
"Testing /infrastructure/field/view/<field_id>"
response = self.client.get(reverse("infrastructure_field_view", args=[self.field.id]))
self.assertRedirects(response, reverse("user_login"))
def test_infrastructure_field_edit_out(self):
"Testing /infrastructure/field/edit/<field_id>"
response = self.client.get(reverse("infrastructure_field_edit", args=[self.field.id]))
self.assertRedirects(response, reverse("user_login"))
def test_infrastructure_field_del_out(self):
"Testing /infrastructure/field/delete/<field_id>"
response = self.client.get(reverse("infrastructure_field_delete", args=[self.field.id]))
self.assertRedirects(response, reverse("user_login"))
# Status
def test_infrastructure_status_add_out(self):
"Testing /infrastructure/status/add/"
response = self.client.get(reverse("infrastructure_status_add"))
self.assertRedirects(response, reverse("user_login"))
def test_infrastructure_status_view_out(self):
"Testing /infrastructure/status/view/<status_id>"
response = self.client.get(reverse("infrastructure_status_view", args=[self.status.id]))
self.assertRedirects(response, reverse("user_login"))
def test_infrastructure_status_edit_out(self):
"Testing /infrastructure/status/edit/<status_id>"
response = self.client.get(reverse("infrastructure_status_edit", args=[self.status.id]))
self.assertRedirects(response, reverse("user_login"))
def test_infrastructure_status_del_out(self):
"Testing /infrastructure/status/delete/<status_id>"
response = self.client.get(reverse("infrastructure_status_delete", args=[self.status.id]))
self.assertRedirects(response, reverse("user_login"))
# Item
def test_infrastructure_item_add_out(self):
"Testing /infrastructure/item/add/"
response = self.client.get(reverse("infrastructure_item_add"))
self.assertRedirects(response, reverse("user_login"))
def test_infr_item_add_typed_out(self):
"Testing /infrastructure/item/add/<type_id>"
response = self.client.get(reverse("infrastructure_item_add_typed", args=[self.type.id]))
self.assertRedirects(response, reverse("user_login"))
def test_infrastructure_item_view_out(self):
"Testing /infrastructure/item/view/<item_id>"
response = self.client.get(reverse("infrastructure_item_view", args=[self.item.id]))
self.assertRedirects(response, reverse("user_login"))
def test_infrastructure_item_edit_out(self):
"Testing /infrastructure/item/edit/<item_id>"
response = self.client.get(reverse("infrastructure_item_edit", args=[self.item.id]))
self.assertRedirects(response, reverse("user_login"))
def test_infrastructure_item_del_out(self):
"Testing /infrastructure/item/delete/<item_id>"
response = self.client.get(reverse("infrastructure_item_delete", args=[self.item.id]))
self.assertRedirects(response, reverse("user_login"))
# Service Record
def test_infr_service_record_index_out(self):
"Testing /infrastructure/service_record/index/"
response = self.client.get(reverse("infrastructure_service_record_index"))
self.assertRedirects(response, reverse("user_login"))
def test_infr_service_record_add_out(self):
"Testing /infrastructure/service_record/add/"
response = self.client.get(reverse("infrastructure_service_record_add"))
self.assertRedirects(response, reverse("user_login"))
def test_infr_service_record_view_out(self):
"Testing /infrastructure/service_record/view/<service_record_id>"
response = self.client.get(reverse("infrastructure_service_record_view", args=[self.servicing.id]))
self.assertRedirects(response, reverse("user_login"))
def test_infr_service_record_edit_out(self):
"Testing /infrastructure/service_record/edit/<service_record_id>"
response = self.client.get(reverse("infrastructure_service_record_edit", args=[self.servicing.id]))
self.assertRedirects(response, reverse("user_login"))
def test_infr_service_record_delete_out(self):
"Testing /infrastructure/service_record/delete/<service_record_id>"
response = self.client.get(reverse("infrastructure_service_record_delete", args=[self.servicing.id]))
self.assertRedirects(response, reverse("user_login"))
class FinanceViewsTest(TestCase):
"Finance functional tests for views"
username = "******"
password = "******"
prepared = False
def setUp(self):
"Initial Setup"
if not self.prepared:
# Clean up first
Object.objects.all().delete()
User.objects.all().delete()
# Create objects
try:
self.group = Group.objects.get(name='test')
except Group.DoesNotExist:
Group.objects.all().delete()
self.group = Group(name='test')
self.group.save()
try:
self.user = DjangoUser.objects.get(username=self.username)
self.user.set_password(self.password)
try:
self.profile = self.user.get_profile()
except Exception:
User.objects.all().delete()
self.user = DjangoUser(username=self.username, password='')
self.user.set_password(self.password)
self.user.save()
except DjangoUser.DoesNotExist:
User.objects.all().delete()
self.user = DjangoUser(username=self.username, password='')
self.user.set_password(self.password)
self.user.save()
try:
perspective = Perspective.objects.get(name='default')
except Perspective.DoesNotExist:
Perspective.objects.all().delete()
perspective = Perspective(name='default')
perspective.set_default_user()
perspective.save()
ModuleSetting.set('default_perspective', perspective.id)
self.contact_type = ContactType(name='test')
self.contact_type.set_default_user()
self.contact_type.save()
self.contact = Contact(name='test', contact_type=self.contact_type)
self.contact.set_default_user()
self.contact.save()
self.category = Category(name='test')
self.category.set_default_user()
self.category.save()
self.equity = Equity(issue_price=10,
sell_price=10,
issuer=self.contact,
owner=self.contact)
self.equity.set_default_user()
self.equity.save()
self.asset = Asset(name='test', owner=self.contact)
self.asset.set_default_user()
self.asset.save()
self.tax = Tax(name='test', rate=10)
self.tax.set_default_user()
self.tax.save()
self.currency = Currency(code="GBP",
name="Pounds",
symbol="L",
is_default=True)
self.currency.set_default_user()
self.currency.save()
self.account = Account(name='test',
owner=self.contact,
balance_currency=self.currency)
self.account.set_default_user()
self.account.save()
self.liability = Liability(name='test',
source=self.contact,
target=self.contact,
account=self.account,
value=10,
value_currency=self.currency)
self.liability.set_default_user()
self.liability.save()
self.transaction = Transaction(name='test',
account=self.account,
source=self.contact,
target=self.contact,
value=10,
value_currency=self.currency)
self.transaction.set_default_user()
self.transaction.save()
self.client = Client()
self.prepared = True
######################################
# Testing views when user is logged in
######################################
def test_finance_login(self):
"Test index page with login at /finance/"
response = self.client.post('/accounts/login', {
'username': self.username,
'password': self.password
})
self.assertRedirects(response, '/')
response = self.client.get(reverse('finance'))
self.assertEquals(response.status_code, 200)
def test_finance_index_login(self):
"Test index page with login at /finance/index/"
response = self.client.post('/accounts/login', {
'username': self.username,
'password': self.password
})
self.assertRedirects(response, '/')
response = self.client.get(reverse('finance_index_transactions'))
self.assertEquals(response.status_code, 200)
def test_finance_income(self):
"Test index page with login at /finance/income/"
response = self.client.post('/accounts/login', {
'username': self.username,
'password': self.password
})
self.assertRedirects(response, '/')
response = self.client.get(reverse('finance_income_view'))
self.assertEquals(response.status_code, 200)
def test_finance_balance(self):
"Test index page with login at /finance/balance/"
response = self.client.post('/accounts/login', {
'username': self.username,
'password': self.password
})
self.assertRedirects(response, '/')
response = self.client.get(reverse('finance_balance_sheet'))
self.assertEquals(response.status_code, 200)
# Account
def test_finance_accounts_index(self):
"Test index page with login at /finance/accounts/"
response = self.client.post('/accounts/login', {
'username': self.username,
'password': self.password
})
self.assertRedirects(response, '/')
response = self.client.get(reverse('finance_index_accounts'))
self.assertEquals(response.status_code, 200)
def test_finance_account_add(self):
"Test index page with login at /finance/account/add/"
response = self.client.post('/accounts/login', {
'username': self.username,
'password': self.password
})
self.assertRedirects(response, '/')
response = self.client.get(reverse('finance_account_add'))
self.assertEquals(response.status_code, 200)
def test_finance_account_edit(self):
"Test index page with login at /finance/account/edit/<account_id>"
response = self.client.post('/accounts/login', {
'username': self.username,
'password': self.password
})
self.assertRedirects(response, '/')
response = self.client.get(
reverse('finance_account_edit', args=[self.account.id]))
self.assertEquals(response.status_code, 200)
def test_finance_account_view(self):
"Test index page with login at /finance/account/view/<account_id>"
response = self.client.post('/accounts/login', {
'username': self.username,
'password': self.password
})
self.assertRedirects(response, '/')
response = self.client.get(
reverse('finance_account_view', args=[self.account.id]))
self.assertEquals(response.status_code, 200)
def test_finance_account_delete(self):
"Test index page with login at /finance/account/delete/<account_id>"
response = self.client.post('/accounts/login', {
'username': self.username,
'password': self.password
})
self.assertRedirects(response, '/')
response = self.client.get(
reverse('finance_account_delete', args=[self.account.id]))
self.assertEquals(response.status_code, 200)
# Asset
def test_finance_assets_index(self):
"Test index page with login at /finance/assets/"
response = self.client.post('/accounts/login', {
'username': self.username,
'password': self.password
})
self.assertRedirects(response, '/')
response = self.client.get(reverse('finance_index_assets'))
self.assertEquals(response.status_code, 200)
def test_finance_asset_add(self):
"Test index page with login at /finance/asset/add/"
response = self.client.post('/accounts/login', {
'username': self.username,
'password': self.password
})
self.assertRedirects(response, '/')
response = self.client.get(reverse('finance_asset_add'))
self.assertEquals(response.status_code, 200)
def test_finance_asset_edit(self):
"Test index page with login at /finance/asset/edit/<asset_id>"
response = self.client.post('/accounts/login', {
'username': self.username,
'password': self.password
})
self.assertRedirects(response, '/')
response = self.client.get(
reverse('finance_asset_edit', args=[self.asset.id]))
self.assertEquals(response.status_code, 200)
def test_finance_asset_view(self):
"Test index page with login at /finance/asset/view/<asset_id>"
response = self.client.post('/accounts/login', {
'username': self.username,
'password': self.password
})
self.assertRedirects(response, '/')
response = self.client.get(
reverse('finance_asset_view', args=[self.asset.id]))
self.assertEquals(response.status_code, 200)
def test_finance_asset_delete(self):
"Test index page with login at /finance/asset/delete/<asset_id>"
response = self.client.post('/accounts/login', {
'username': self.username,
'password': self.password
})
self.assertRedirects(response, '/')
response = self.client.get(
reverse('finance_asset_delete', args=[self.asset.id]))
self.assertEquals(response.status_code, 200)
# Equity
def test_finance_equity_index(self):
"Test index page with login at /finance/equity/"
response = self.client.post('/accounts/login', {
'username': self.username,
'password': self.password
})
self.assertRedirects(response, '/')
response = self.client.get(reverse('finance_index_equities'))
self.assertEquals(response.status_code, 200)
def test_finance_equity_add(self):
"Test index page with login at /finance/equity/add/"
response = self.client.post('/accounts/login', {
'username': self.username,
'password': self.password
})
self.assertRedirects(response, '/')
response = self.client.get(reverse('finance_equity_add'))
self.assertEquals(response.status_code, 200)
def test_finance_equity_edit(self):
"Test index page with login at /finance/equity/edit/<equity_id>"
response = self.client.post('/accounts/login', {
'username': self.username,
'password': self.password
})
self.assertRedirects(response, '/')
response = self.client.get(
reverse('finance_equity_edit', args=[self.equity.id]))
self.assertEquals(response.status_code, 200)
def test_finance_equity_view(self):
"Test index page with login at /finance/equity/view/<equity_id>"
response = self.client.post('/accounts/login', {
'username': self.username,
'password': self.password
})
self.assertRedirects(response, '/')
response = self.client.get(
reverse('finance_equity_view', args=[self.equity.id]))
self.assertEquals(response.status_code, 200)
def test_finance_equity_delete(self):
"Test index page with login at /finance/equity/delete/<equity_id>"
response = self.client.post('/accounts/login', {
'username': self.username,
'password': self.password
})
self.assertRedirects(response, '/')
response = self.client.get(
reverse('finance_equity_delete', args=[self.equity.id]))
self.assertEquals(response.status_code, 200)
# Transaction
def test_finance_transactions_index(self):
"Test index page with login at /finance/transaction/"
response = self.client.post('/accounts/login', {
'username': self.username,
'password': self.password
})
self.assertRedirects(response, '/')
response = self.client.get(reverse('finance_index_transactions'))
self.assertEquals(response.status_code, 200)
def test_finance_transaction_add(self):
"Test index page with login at /finance/transaction/add/"
response = self.client.post('/accounts/login', {
'username': self.username,
'password': self.password
})
self.assertRedirects(response, '/')
response = self.client.get(reverse('finance_transaction_add'))
self.assertEquals(response.status_code, 200)
def test_finance_transaction_add_liability(self):
"Test index page with login at /finance/transaction/add/liability/(?P<liability_id>\d+)"
response = self.client.post('/accounts/login', {
'username': self.username,
'password': self.password
})
self.assertRedirects(response, '/')
response = self.client.get(
reverse('finance_transaction_add', args=[self.liability.id]))
self.assertEquals(response.status_code, 200)
def test_finance_transaction_edit(self):
"Test index page with login at /finance/transaction/edit/<transaction_id>"
response = self.client.post('/accounts/login', {
'username': self.username,
'password': self.password
})
self.assertRedirects(response, '/')
response = self.client.get(
reverse('finance_transaction_edit', args=[self.transaction.id]))
self.assertEquals(response.status_code, 200)
def test_finance_transaction_view(self):
"Test index page with login at /finance/transaction/view/<transaction_id>"
response = self.client.post('/accounts/login', {
'username': self.username,
'password': self.password
})
self.assertRedirects(response, '/')
response = self.client.get(
reverse('finance_transaction_view', args=[self.transaction.id]))
self.assertEquals(response.status_code, 200)
def test_finance_transaction_delete(self):
"Test index page with login at /finance/transaction/delete/<transaction_id>"
response = self.client.post('/accounts/login', {
'username': self.username,
'password': self.password
})
self.assertRedirects(response, '/')
response = self.client.get(
reverse('finance_transaction_delete', args=[self.transaction.id]))
self.assertEquals(response.status_code, 200)
# Liability
def test_finance_liability_index(self):
"Test index page with login at /finance/liability/"
response = self.client.post('/accounts/login', {
'username': self.username,
'password': self.password
})
self.assertRedirects(response, '/')
response = self.client.get(reverse('finance_index_liabilities'))
self.assertEquals(response.status_code, 200)
def test_finance_liability_add(self):
"Test index page with login at /finance/liability/add/"
response = self.client.post('/accounts/login', {
'username': self.username,
'password': self.password
})
self.assertRedirects(response, '/')
response = self.client.get(reverse('finance_liability_add'))
self.assertEquals(response.status_code, 200)
def test_finance_liability_edit(self):
"Test index page with login at /finance/liability/edit/<liability_id>"
response = self.client.post('/accounts/login', {
'username': self.username,
'password': self.password
})
self.assertRedirects(response, '/')
response = self.client.get(
reverse('finance_liability_edit', args=[self.liability.id]))
self.assertEquals(response.status_code, 200)
def test_finance_liability_view(self):
"Test index page with login at /finance/liability/view/<liability_id>"
response = self.client.post('/accounts/login', {
'username': self.username,
'password': self.password
})
self.assertRedirects(response, '/')
response = self.client.get(
reverse('finance_liability_view', args=[self.liability.id]))
self.assertEquals(response.status_code, 200)
def test_finance_liability_delete(self):
"Test index page with login at /finance/liability/delete/<liability_id>"
response = self.client.post('/accounts/login', {
'username': self.username,
'password': self.password
})
self.assertRedirects(response, '/')
response = self.client.get(
reverse('finance_liability_delete', args=[self.liability.id]))
self.assertEquals(response.status_code, 200)
# Receivables
def test_finance_receivables_index(self):
"Test index page with login at /finance/receivables/"
response = self.client.post('/accounts/login', {
'username': self.username,
'password': self.password
})
self.assertRedirects(response, '/')
response = self.client.get(reverse('finance_index_receivables'))
self.assertEquals(response.status_code, 200)
def test_finance_receivable_add(self):
"Test index page with login at /finance/receivable/add/"
response = self.client.post('/accounts/login', {
'username': self.username,
'password': self.password
})
self.assertRedirects(response, '/')
response = self.client.get(reverse('finance_receivable_add'))
self.assertEquals(response.status_code, 200)
def test_finance_receivable_edit(self):
"Test index page with login at /finance/receivable/edit/<receivable_id>"
response = self.client.post('/accounts/login', {
'username': self.username,
'password': self.password
})
self.assertRedirects(response, '/')
response = self.client.get(
reverse('finance_receivable_edit', args=[self.liability.id]))
self.assertEquals(response.status_code, 200)
def test_finance_receivable_view(self):
"Test index page with login at /finance/receivable/view/<receivable_id>"
response = self.client.post('/accounts/login', {
'username': self.username,
'password': self.password
})
self.assertRedirects(response, '/')
response = self.client.get(
reverse('finance_receivable_view', args=[self.liability.id]))
self.assertEquals(response.status_code, 200)
def test_finance_receivable_delete(self):
"Test index page with login at /finance/liability/delete/<receivable_id>"
response = self.client.post('/accounts/login', {
'username': self.username,
'password': self.password
})
self.assertRedirects(response, '/')
response = self.client.get(
reverse('finance_receivable_delete', args=[self.liability.id]))
self.assertEquals(response.status_code, 200)
# Category
def test_finance_category_add(self):
"Test index page with login at /finance/category/add/"
response = self.client.post('/accounts/login', {
'username': self.username,
'password': self.password
})
self.assertRedirects(response, '/')
response = self.client.get(reverse('finance_category_add'))
self.assertEquals(response.status_code, 200)
def test_finance_category_edit(self):
"Test index page with login at /finance/category/edit/<category_id>"
response = self.client.post('/accounts/login', {
'username': self.username,
'password': self.password
})
self.assertRedirects(response, '/')
response = self.client.get(
reverse('finance_category_edit', args=[self.category.id]))
self.assertEquals(response.status_code, 200)
def test_finance_category_view(self):
"Test index page with login at /finance/category/view/<category_id>"
response = self.client.post('/accounts/login', {
'username': self.username,
'password': self.password
})
self.assertRedirects(response, '/')
response = self.client.get(
reverse('finance_category_view', args=[self.category.id]))
self.assertEquals(response.status_code, 200)
def test_finance_category_delete(self):
"Test index page with login at /finance/category/delete/<category_id>"
response = self.client.post('/accounts/login', {
'username': self.username,
'password': self.password
})
self.assertRedirects(response, '/')
response = self.client.get(
reverse('finance_category_delete', args=[self.category.id]))
self.assertEquals(response.status_code, 200)
# Currency
def test_finance_currency_add(self):
"Test index page with login at /finance/currency/add/"
response = self.client.post('/accounts/login', {
'username': self.username,
'password': self.password
})
self.assertRedirects(response, '/')
response = self.client.get(reverse('finance_currency_add'))
self.assertEquals(response.status_code, 200)
def test_finance_currency_edit(self):
"Test index page with login at /finance/currency/edit/<currency_id>"
response = self.client.post('/accounts/login', {
'username': self.username,
'password': self.password
})
self.assertRedirects(response, '/')
response = self.client.get(
reverse('finance_currency_edit', args=[self.currency.id]))
self.assertEquals(response.status_code, 200)
def test_finance_currency_view(self):
"Test index page with login at /finance/currency/view/<currency_id>"
response = self.client.post('/accounts/login', {
'username': self.username,
'password': self.password
})
self.assertRedirects(response, '/')
response = self.client.get(
reverse('finance_currency_view', args=[self.currency.id]))
self.assertEquals(response.status_code, 200)
def test_finance_currency_delete(self):
"Test index page with login at /finance/currency/delete/<currency_id>"
response = self.client.post('/accounts/login', {
'username': self.username,
'password': self.password
})
self.assertRedirects(response, '/')
response = self.client.get(
reverse('finance_currency_delete', args=[self.currency.id]))
self.assertEquals(response.status_code, 200)
# Taxes
def test_finance_tax_add(self):
"Test index page with login at /finance/tax/add/"
response = self.client.post('/accounts/login', {
'username': self.username,
'password': self.password
})
self.assertRedirects(response, '/')
response = self.client.get(reverse('finance_tax_add'))
self.assertEquals(response.status_code, 200)
def test_finance_tax_edit(self):
"Test index page with login at /finance/tax/edit/<tax_id>"
response = self.client.post('/accounts/login', {
'username': self.username,
'password': self.password
})
self.assertRedirects(response, '/')
response = self.client.get(
reverse('finance_tax_edit', args=[self.tax.id]))
self.assertEquals(response.status_code, 200)
def test_finance_tax_view(self):
"Test index page with login at /finance/tax/view/<tax_id>"
response = self.client.post('/accounts/login', {
'username': self.username,
'password': self.password
})
self.assertRedirects(response, '/')
response = self.client.get(
reverse('finance_tax_view', args=[self.tax.id]))
self.assertEquals(response.status_code, 200)
def test_finance_tax_delete(self):
"Test index page with login at /finance/tax/delete/<tax_id>"
response = self.client.post('/accounts/login', {
'username': self.username,
'password': self.password
})
self.assertRedirects(response, '/')
response = self.client.get(
reverse('finance_tax_delete', args=[self.tax.id]))
self.assertEquals(response.status_code, 200)
# Settings
def test_finance_settings_view(self):
"Test index page with login at /finance/settings/view/"
response = self.client.post('/accounts/login', {
'username': self.username,
'password': self.password
})
self.assertRedirects(response, '/')
response = self.client.get(reverse('finance_settings_view'))
self.assertEquals(response.status_code, 200)
def test_finance_settings_edit(self):
"Test index page with login at /finance/settings/edit/"
response = self.client.post('/accounts/login', {
'username': self.username,
'password': self.password
})
self.assertRedirects(response, '/')
response = self.client.get(reverse('finance_settings_edit'))
self.assertEquals(response.status_code, 200)
######################################
# Testing views when user is not logged in
######################################
def test_index(self):
"Test index page at /finance/"
response = self.client.get('/finance/')
# Redirects as unauthenticated
self.assertRedirects(response, reverse('user_login'))
def test_finance_index_out(self):
"Testing /finance/index/"
response = self.client.get(reverse('finance_index_transactions'))
self.assertRedirects(response, reverse('user_login'))
def test_finance_income_out(self):
"Testing /finance/income/"
response = self.client.get(reverse('finance_income_view'))
self.assertRedirects(response, reverse('user_login'))
def test_finance_balance_out(self):
"Testing /finance/balance/"
response = self.client.get(reverse('finance_balance_sheet'))
self.assertRedirects(response, reverse('user_login'))
# Account
def test_finance_accounts_index_out(self):
"Testing /finance/accounts/"
response = self.client.get(reverse('finance_index_accounts'))
self.assertRedirects(response, reverse('user_login'))
def test_finance_account_add_out(self):
"Testing /finance/account/add/"
response = self.client.get(reverse('finance_account_add'))
self.assertRedirects(response, reverse('user_login'))
def test_finance_account_edit_out(self):
"Testing /finance/account/edit/<account_id>"
response = self.client.get(
reverse('finance_account_edit', args=[self.account.id]))
self.assertRedirects(response, reverse('user_login'))
def test_finance_account_view_out(self):
"Testing /finance/account/view/<account_id>"
response = self.client.get(
reverse('finance_account_view', args=[self.account.id]))
self.assertRedirects(response, reverse('user_login'))
def test_finance_account_delete_out(self):
"Testing /finance/account/delete/<account_id>"
response = self.client.get(
reverse('finance_account_delete', args=[self.account.id]))
self.assertRedirects(response, reverse('user_login'))
# Asset
def test_finance_assets_index_out(self):
"Testing /finance/assets/"
response = self.client.get(reverse('finance_index_assets'))
self.assertRedirects(response, reverse('user_login'))
def test_finance_asset_add_out(self):
"Testing /finance/asset/add/"
response = self.client.get(reverse('finance_asset_add'))
self.assertRedirects(response, reverse('user_login'))
def test_finance_asset_edit_out(self):
"Testing /finance/asset/edit/<asset_id>"
response = self.client.get(
reverse('finance_asset_edit', args=[self.asset.id]))
self.assertRedirects(response, reverse('user_login'))
def test_finance_asset_view_out(self):
"Testing /finance/asset/view/<asset_id>"
response = self.client.get(
reverse('finance_asset_view', args=[self.asset.id]))
self.assertRedirects(response, reverse('user_login'))
def test_finance_asset_delete_out(self):
"Testing /finance/asset/delete/<asset_id>"
response = self.client.get(
reverse('finance_asset_delete', args=[self.asset.id]))
self.assertRedirects(response, reverse('user_login'))
# Equity
def test_finance_equity_index_out(self):
"Testing /finance/equity/"
response = self.client.get(reverse('finance_index_equities'))
self.assertRedirects(response, reverse('user_login'))
def test_finance_equity_add_out(self):
"Testing /finance/equity/add/"
response = self.client.get(reverse('finance_equity_add'))
self.assertRedirects(response, reverse('user_login'))
def test_finance_equity_edit_out(self):
"Tesing /finance/equity/edit/<equity_id>"
response = self.client.get(
reverse('finance_equity_edit', args=[self.equity.id]))
self.assertRedirects(response, reverse('user_login'))
def test_finance_equity_view_out(self):
"Testing /finance/equity/view/<equity_id>"
response = self.client.get(
reverse('finance_equity_view', args=[self.equity.id]))
self.assertRedirects(response, reverse('user_login'))
def test_finance_equity_delete_out(self):
"Testing /finance/equity/delete/<equity_id>"
response = self.client.get(
reverse('finance_equity_delete', args=[self.equity.id]))
self.assertRedirects(response, reverse('user_login'))
# Transaction
def test_finance_transactions_index_out(self):
"Testing /finance/transaction/"
response = self.client.get(reverse('finance_index_transactions'))
self.assertRedirects(response, reverse('user_login'))
def test_finance_transaction_add_out(self):
"Testing /finance/transaction/add/"
response = self.client.get(reverse('finance_transaction_add'))
self.assertRedirects(response, reverse('user_login'))
def test_finance_transaction_add_liability_out(self):
"Testing /finance/transaction/add/liability/(?P<liability_id>\d+)"
response = self.client.get(
reverse('finance_transaction_add', args=[self.liability.id]))
self.assertRedirects(response, reverse('user_login'))
def test_finance_transaction_edit_out(self):
"Testing /finance/transaction/edit/<transaction_id>"
response = self.client.get(
reverse('finance_transaction_edit', args=[self.transaction.id]))
self.assertRedirects(response, reverse('user_login'))
def test_finance_transaction_view_out(self):
"Testing /finance/transaction/view/<transaction_id>"
response = self.client.get(
reverse('finance_transaction_view', args=[self.transaction.id]))
self.assertRedirects(response, reverse('user_login'))
def test_finance_transaction_delete_out(self):
"Testing /finance/transaction/delete/<transaction_id>"
response = self.client.get(
reverse('finance_transaction_delete', args=[self.transaction.id]))
self.assertRedirects(response, reverse('user_login'))
# Liability
def test_finance_liability_index_out(self):
"Testing /finance/liability/"
response = self.client.get(reverse('finance_index_liabilities'))
self.assertRedirects(response, reverse('user_login'))
def test_finance_liability_add_out(self):
"Testing /finance/liability/add/"
response = self.client.get(reverse('finance_liability_add'))
self.assertRedirects(response, reverse('user_login'))
def test_finance_liability_edit_out(self):
"Testing /finance/liability/edit/<liability_id>"
response = self.client.get(
reverse('finance_liability_edit', args=[self.liability.id]))
self.assertRedirects(response, reverse('user_login'))
def test_finance_liability_view_out(self):
"Testing /finance/liability/view/<liability_id>"
response = self.client.get(
reverse('finance_liability_view', args=[self.liability.id]))
self.assertRedirects(response, reverse('user_login'))
def test_finance_liability_delete_out(self):
"Testing /finance/liability/delete/<liability_id>"
response = self.client.get(
reverse('finance_liability_delete', args=[self.liability.id]))
self.assertRedirects(response, reverse('user_login'))
# Receivables
def test_finance_receivables_index_out(self):
"Testing /finance/receivables/"
response = self.client.get(reverse('finance_index_receivables'))
self.assertRedirects(response, reverse('user_login'))
def test_finance_receivable_add_out(self):
"Testing /finance/receivable/add/"
response = self.client.get(reverse('finance_receivable_add'))
self.assertRedirects(response, reverse('user_login'))
def test_finance_receivable_edit_out(self):
"Testing /finance/receivable/edit/<receivable_id>"
response = self.client.get(
reverse('finance_receivable_edit', args=[self.liability.id]))
self.assertRedirects(response, reverse('user_login'))
def test_finance_receivable_view_out(self):
"Testing /finance/receivable/view/<receivable_id>"
response = self.client.get(
reverse('finance_receivable_view', args=[self.liability.id]))
self.assertRedirects(response, reverse('user_login'))
def test_finance_receivable_delete_out(self):
"Testing /finance/liability/delete/<receivable_id>"
response = self.client.get(
reverse('finance_receivable_delete', args=[self.liability.id]))
self.assertRedirects(response, reverse('user_login'))
# Category
def test_finance_category_add_out(self):
"Testing /finance/category/add/"
response = self.client.get(reverse('finance_category_add'))
self.assertRedirects(response, reverse('user_login'))
def test_finance_category_edit_out(self):
"Testing /finance/category/edit/<category_id>"
response = self.client.get(
reverse('finance_category_edit', args=[self.category.id]))
self.assertRedirects(response, reverse('user_login'))
def test_finance_category_view_out(self):
"Testing /finance/category/view/<category_id>"
response = self.client.get(
reverse('finance_category_view', args=[self.category.id]))
self.assertRedirects(response, reverse('user_login'))
def test_finance_category_delete_out(self):
"Testing /finance/category/delete/<category_id>"
response = self.client.get(
reverse('finance_category_delete', args=[self.category.id]))
self.assertRedirects(response, reverse('user_login'))
# Currency
def test_finance_currency_add_out(self):
"Testing /finance/currency/add/"
response = self.client.get(reverse('finance_currency_add'))
self.assertRedirects(response, reverse('user_login'))
def test_finance_currency_edit_out(self):
"Testing /finance/currency/edit/<currency_id>"
response = self.client.get(
reverse('finance_currency_edit', args=[self.currency.id]))
self.assertRedirects(response, reverse('user_login'))
def test_finance_currency_view_out(self):
"Testing /finance/currency/view/<currency_id>"
response = self.client.get(
reverse('finance_currency_view', args=[self.currency.id]))
self.assertRedirects(response, reverse('user_login'))
def test_finance_currency_delete_out(self):
"Testing /finance/currency/delete/<currency_id>"
response = self.client.get(
reverse('finance_currency_delete', args=[self.currency.id]))
self.assertRedirects(response, reverse('user_login'))
# Taxes
def test_finance_tax_add_out(self):
"Testing /finance/tax/add/"
response = self.client.get(reverse('finance_tax_add'))
self.assertRedirects(response, reverse('user_login'))
def test_finance_tax_edit_out(self):
"Testing /finance/tax/edit/<tax_id>"
response = self.client.get(
reverse('finance_tax_edit', args=[self.tax.id]))
self.assertRedirects(response, reverse('user_login'))
def test_finance_tax_view_out(self):
"Testing /finance/tax/view/<tax_id>"
response = self.client.get(
reverse('finance_tax_view', args=[self.tax.id]))
self.assertRedirects(response, reverse('user_login'))
def test_finance_tax_delete_out(self):
"Testing /finance/tax/delete/<tax_id>"
response = self.client.get(
reverse('finance_tax_delete', args=[self.tax.id]))
self.assertRedirects(response, reverse('user_login'))
# Settings
def test_finance_settings_view_out(self):
"Testing /finance/settings/view/"
response = self.client.get(reverse('finance_settings_view'))
self.assertRedirects(response, reverse('user_login'))
def test_finance_settings_edit_out(self):
"Testing /finance/settings/edit/"
response = self.client.get(reverse('finance_settings_edit'))
self.assertRedirects(response, reverse('user_login'))
class CoreAPITest(TestCase):
"Core api tests"
username = "******"
password = "******"
prepared = False
authentication_headers ={"CONTENT_TYPE": "application/json",
"HTTP_AUTHORIZATION" : "Basic YXBpX3Rlc3Q6YXBpX3Bhc3N3b3Jk" }
content_type ='application/json'
prepared = False
def setUp(self):
"Initial Setup"
if not self.prepared:
Object.objects.all().delete()
# Create objects
self.group, created = Group.objects.get_or_create(name='test')
duser, created = DjangoUser.objects.get_or_create(username=self.username)
duser.set_password(self.password)
duser.save()
self.user, created = User.objects.get_or_create(user=duser)
self.user.save()
perspective, created = Perspective.objects.get_or_create(name='default')
perspective.set_default_user()
perspective.save()
ModuleSetting.set('default_perspective', perspective.id)
self.perspective = Perspective(name='test')
self.perspective.set_default_user()
self.perspective.save()
self.group = Group(name='test')
self.group.save()
self.client = Client()
self.prepared = True
def test_unauthenticated_access(self):
"Test index page at /admin/api/users"
response = self.client.get('/admin/api/users')
# Redirects as unauthenticated
self.assertEquals(response.status_code, 404)
def test_get_ticket_groups_list(self):
""" Test index page api /admin/api/groups """
response = self.client.get(path=reverse('api_admin_groups'), **self.authentication_headers)
self.assertEquals(response.status_code, 200)
def test_get_group(self):
response = self.client.get(path=reverse('api_admin_groups', kwargs={'accessentity_ptr': self.group.id}), **self.authentication_headers)
print response.content
self.assertEquals(response.status_code, 200)
def test_update_group(self):
updates = {'name': 'Api group name', 'details': '<p>api details</p>', 'perspective': self.perspective.id}
response = self.client.put(path=reverse('api_admin_groups', kwargs={'accessentity_ptr': self.group.id}),
content_type=self.content_type, data=json.dumps(updates), **self.authentication_headers)
print response.content
self.assertEquals(response.status_code, 200)
data = json.loads(response.content)
self.assertEquals(data['name'], updates['name'])
self.assertEquals(data['details'], updates['details'])
self.assertEquals(data['perspective']['id'], updates['perspective'])
def test_get_ticket_users_list(self):
""" Test index page api /admin/api/users """
response = self.client.get(path=reverse('api_admin_users'), **self.authentication_headers)
self.assertEquals(response.status_code, 200)
def test_get_user(self):
response = self.client.get(path=reverse('api_admin_users', kwargs={'accessentity_ptr': self.user.id}), **self.authentication_headers)
print response.content
self.assertEquals(response.status_code, 200)
def test_update_user(self):
updates = {'name': 'Api user name', 'default_group': self.group.id, 'disabled': False,
'perspective': self.perspective.id}
response = self.client.put(path=reverse('api_admin_users', kwargs={'accessentity_ptr': self.user.id}),
content_type=self.content_type, data=json.dumps(updates), **self.authentication_headers)
self.assertEquals(response.status_code, 405)
#data = json.loads(response.content)
#self.assertEquals(data['name'], updates['name'])
#self.assertEquals(data['disabled'], updates['disabled'])
#self.assertEquals(data['default_group']['id'], updates['default_group'])
#self.assertEquals(data['perspective']['id'], updates['perspective'])
def test_delete_self(self):
response = self.client.delete(path=reverse('api_admin_users', kwargs={'accessentity_ptr': self.user.id}), **self.authentication_headers)
self.assertEquals(response.status_code, 401)
def test_get_ticket_modules_list(self):
""" Test index page api /admin/api/modules """
response = self.client.get(path=reverse('api_admin_modules'), **self.authentication_headers)
self.assertEquals(response.status_code, 200)
def test_get_ticket_perspectives_list(self):
""" Test index page api /admin/api/perspectives """
response = self.client.get(path=reverse('api_admin_perspectives'), **self.authentication_headers)
self.assertEquals(response.status_code, 200)
def test_get_perspective(self):
response = self.client.get(path=reverse('api_admin_perspectives', kwargs={'object_ptr': self.perspective.id}), **self.authentication_headers)
self.assertEquals(response.status_code, 200)
def test_update_perspective(self):
updates = {'name': 'Api perspective', 'details': 'Api details'}
response = self.client.put(path=reverse('api_admin_perspectives', kwargs={'object_ptr': self.perspective.id}),
content_type=self.content_type, data=json.dumps(updates), **self.authentication_headers)
self.assertEquals(response.status_code, 200)
data = json.loads(response.content)
self.assertEquals(data['name'], updates['name'])
self.assertEquals(data['details'], updates['details'])
def setUp(self):
"Initial Setup"
if not self.prepared:
# Clean up first
Object.objects.all().delete()
User.objects.all().delete()
# Create objects
try:
self.group = Group.objects.get(name='test')
except Group.DoesNotExist:
Group.objects.all().delete()
self.group = Group(name='test')
self.group.save()
try:
self.user = DjangoUser.objects.get(username=self.username)
self.user.set_password(self.password)
try:
self.profile = self.user.get_profile()
except Exception:
User.objects.all().delete()
self.user = DjangoUser(username=self.username, password='')
self.user.set_password(self.password)
self.user.save()
except DjangoUser.DoesNotExist:
User.objects.all().delete()
self.user = DjangoUser(username=self.username, password='')
self.user.set_password(self.password)
self.user.save()
try:
perspective = Perspective.objects.get(name='default')
except Perspective.DoesNotExist:
Perspective.objects.all().delete()
perspective = Perspective(name='default')
perspective.set_default_user()
perspective.save()
ModuleSetting.set('default_perspective', perspective.id)
self.contact_type = ContactType(name='test')
self.contact_type.set_default_user()
self.contact_type.save()
self.contact = Contact(name='test', contact_type=self.contact_type)
self.contact.set_default_user()
self.contact.save()
self.category = Category(name='test')
self.category.set_default_user()
self.category.save()
self.equity = Equity(issue_price=10,
sell_price=10,
issuer=self.contact,
owner=self.contact)
self.equity.set_default_user()
self.equity.save()
self.asset = Asset(name='test', owner=self.contact)
self.asset.set_default_user()
self.asset.save()
self.tax = Tax(name='test', rate=10)
self.tax.set_default_user()
self.tax.save()
self.currency = Currency(code="GBP",
name="Pounds",
symbol="L",
is_default=True)
self.currency.set_default_user()
self.currency.save()
self.account = Account(name='test',
owner=self.contact,
balance_currency=self.currency)
self.account.set_default_user()
self.account.save()
self.liability = Liability(name='test',
source=self.contact,
target=self.contact,
account=self.account,
value=10,
value_currency=self.currency)
self.liability.set_default_user()
self.liability.save()
self.transaction = Transaction(name='test',
account=self.account,
source=self.contact,
target=self.contact,
value=10,
value_currency=self.currency)
self.transaction.set_default_user()
self.transaction.save()
self.client = Client()
self.prepared = True
class DocumentsViewsTest(TestCase):
"Documents functional tests for api"
username = "******"
password = "******"
prepared = False
authentication_headers = {"CONTENT_TYPE": "application/json",
"HTTP_AUTHORIZATION": "Basic YXBpX3Rlc3Q6YXBpX3Bhc3N3b3Jk"}
content_type = 'application/json'
def setUp(self):
"Initial Setup"
if not self.prepared:
Object.objects.all().delete()
# Create objects
try:
self.group = Group.objects.get(name='test')
except Group.DoesNotExist:
Group.objects.all().delete()
self.group = Group(name='test')
self.group.save()
try:
self.user = DjangoUser.objects.get(username=self.username)
self.user.set_password(self.password)
try:
self.profile = self.user.get_profile()
except Exception:
User.objects.all().delete()
self.user = DjangoUser(username=self.username, password='')
self.user.set_password(self.password)
self.user.save()
except DjangoUser.DoesNotExist:
User.objects.all().delete()
self.user = DjangoUser(username=self.username, password='')
self.user.set_password(self.password)
self.user.save()
try:
perspective = Perspective.objects.get(name='default')
except Perspective.DoesNotExist:
Perspective.objects.all().delete()
perspective = Perspective(name='default')
perspective.set_default_user()
perspective.save()
ModuleSetting.set('default_perspective', perspective.id)
self.folder = Folder(name='test')
self.folder.set_default_user()
self.folder.save()
self.document = Document(title='test_document', folder=self.folder)
self.document.set_default_user()
self.document.save()
self.file = File(name='test_file', folder=self.folder)
self.file.set_default_user()
self.file.save()
self.link = WebLink(title='test', folder=self.folder, url='test')
self.link.set_default_user()
self.link.save()
self.client = Client()
self.prepared = True
def test_unauthenticated_access(self):
"Test index page at /api/documents/folders"
response = self.client.get('/api/documents/folders')
# Redirects as unauthenticated
self.assertEquals(response.status_code, 401)
def test_get_folders_list(self):
""" Test index page api/documents/folders """
response = self.client.get(
path=reverse('api_documents_folders'), **self.authentication_headers)
self.assertEquals(response.status_code, 200)
def test_get_folder(self):
response = self.client.get(path=reverse('api_documents_folders', kwargs={
'object_ptr': self.folder.id}), **self.authentication_headers)
self.assertEquals(response.status_code, 200)
def test_update_folder(self):
updates = {"name": "Api_folder_name"}
response = self.client.put(path=reverse('api_documents_folders', kwargs={'object_ptr': self.folder.id}),
content_type=self.content_type, data=json.dumps(updates), **self.authentication_headers)
self.assertEquals(response.status_code, 200)
data = json.loads(response.content)
self.assertEquals(data['name'], updates['name'])
def test_get_files_list(self):
""" Test index page api/documents/files """
response = self.client.get(
path=reverse('api_documents_files'), **self.authentication_headers)
self.assertEquals(response.status_code, 200)
def test_get_file(self):
response = self.client.get(path=reverse('api_documents_files', kwargs={
'object_ptr': self.file.id}), **self.authentication_headers)
self.assertEquals(response.status_code, 200)
# def test_update_file(self):
# updates = { "name": "Api_folder_name" }
# response = self.client.put(path=reverse('api_documents_files', kwargs={'object_ptr': self.file.id}),
# content_type=self.content_type, data=json.dumps(updates), **self.authentication_headers)
# self.assertEquals(response.status_code, 200)
#
# data = json.loads(response.content)
# self.assertEquals(data['name'], updates['name'])
def test_get_documents_list(self):
""" Test index page api/documents/documents """
response = self.client.get(
path=reverse('api_documents_documents'), **self.authentication_headers)
self.assertEquals(response.status_code, 200)
def test_get_document(self):
response = self.client.get(path=reverse('api_documents_documents', kwargs={
'object_ptr': self.document.id}), **self.authentication_headers)
self.assertEquals(response.status_code, 200)
def test_update_document(self):
updates = {"title": "Api_title",
"folder": self.folder.id, "body": "Api test body"}
response = self.client.put(path=reverse('api_documents_documents', kwargs={'object_ptr': self.document.id}),
content_type=self.content_type, data=json.dumps(updates), **self.authentication_headers)
self.assertEquals(response.status_code, 200)
data = json.loads(response.content)
self.assertEquals(data['title'], updates['title'])
self.assertEquals(data['folder']['id'], updates['folder'])
self.assertEquals(data['body'], updates['body'])
def test_get_weblinks_list(self):
""" Test index page api/documents/weblinks """
response = self.client.get(
path=reverse('api_documents_weblinks'), **self.authentication_headers)
self.assertEquals(response.status_code, 200)
def test_get_weblink(self):
response = self.client.get(path=reverse('api_documents_weblinks', kwargs={
'object_ptr': self.link.id}), **self.authentication_headers)
self.assertEquals(response.status_code, 200)
def test_update_weblink(self):
updates = {"title": "Api_title", "folder": self.folder.id,
"url": "http://Api-test-body"}
response = self.client.put(path=reverse('api_documents_weblinks', kwargs={'object_ptr': self.link.id}),
content_type=self.content_type, data=json.dumps(updates), **self.authentication_headers)
self.assertEquals(response.status_code, 200)
data = json.loads(response.content)
self.assertEquals(data['title'], updates['title'])
self.assertEquals(data['folder']['id'], updates['folder'])
self.assertEquals(data['url'], updates['url'])
class DocumentsViewsTest(TestCase):
"Documents functional tests for views"
username = "******"
password = "******"
prepared = False
def setUp(self):
"Initial Setup"
if not self.prepared:
Object.objects.all().delete()
# Create objects
try:
self.group = Group.objects.get(name='test')
except Group.DoesNotExist:
Group.objects.all().delete()
self.group = Group(name='test')
self.group.save()
try:
self.user = DjangoUser.objects.get(username=self.username)
self.user.set_password(self.password)
try:
self.profile = self.user.get_profile()
except Exception:
User.objects.all().delete()
self.user = DjangoUser(username=self.username, password='')
self.user.set_password(self.password)
self.user.save()
except DjangoUser.DoesNotExist:
User.objects.all().delete()
self.user = DjangoUser(username=self.username, password='')
self.user.set_password(self.password)
self.user.save()
try:
perspective = Perspective.objects.get(name='default')
except Perspective.DoesNotExist:
Perspective.objects.all().delete()
perspective = Perspective(name='default')
perspective.set_default_user()
perspective.save()
ModuleSetting.set('default_perspective', perspective.id)
self.folder = Folder(name='test')
self.folder.set_default_user()
self.folder.save()
self.document = Document(title='test_document', folder=self.folder)
self.document.set_default_user()
self.document.save()
self.file = File(name='test_file', folder=self.folder)
self.file.set_default_user()
self.file.save()
self.link = WebLink(title='test', folder=self.folder, url='test')
self.link.set_default_user()
self.link.save()
self.client = Client()
self.prepared = True
######################################
# Testing views when user is logged in
######################################
def test_index_login(self):
"Test index page with login at /documents/"
response = self.client.post('/accounts/login', {
'username': self.username,
'password': self.password
})
self.assertRedirects(response, '/')
response = self.client.get(reverse('document_index'))
self.assertEquals(response.status_code, 200)
def test_index_documents_login(self):
"Test index page with login at /documents/documents/"
response = self.client.post('/accounts/login', {
'username': self.username,
'password': self.password
})
self.assertRedirects(response, '/')
response = self.client.get(reverse('index_documents'))
self.assertEquals(response.status_code, 200)
def test_index_files_login(self):
"Test index page with login at /documents/files/"
response = self.client.post('/accounts/login', {
'username': self.username,
'password': self.password
})
self.assertRedirects(response, '/')
response = self.client.get(reverse('index_files'))
self.assertEquals(response.status_code, 200)
def test_index_weblinks_login(self):
"Test index page with login at /documents/weblinks/"
response = self.client.post('/accounts/login', {
'username': self.username,
'password': self.password
})
self.assertRedirects(response, '/')
response = self.client.get(reverse('index_weblinks'))
self.assertEquals(response.status_code, 200)
# Folders
def test_folder_add(self):
"Test index page with login at /documents/folder/add/"
response = self.client.post('/accounts/login', {
'username': self.username,
'password': self.password
})
self.assertRedirects(response, '/')
response = self.client.get(reverse('documents_folder_add'))
self.assertEquals(response.status_code, 200)
# form
self.assertEqual(Folder.objects.count(), 1)
post_data = {'name': 'test'}
response = self.client.post(reverse('documents_folder_add'), post_data)
self.assertEquals(response.status_code, 302) # redirect somewhere
self.assertEquals(Folder.objects.count(), 2)
def test_folder_view_login(self):
"Test index page with login at /documents/folder/view/<folder_id>"
response = self.client.post('/accounts/login', {
'username': self.username,
'password': self.password
})
self.assertRedirects(response, '/')
response = self.client.get(
reverse('documents_folder_view', args=[self.folder.id]))
self.assertEquals(response.status_code, 200)
def test_folder_edit_login(self):
"Test index page with login at /documents/folder/edit/<folder_id>"
response = self.client.post('/accounts/login', {
'username': self.username,
'password': self.password
})
self.assertRedirects(response, '/')
response = self.client.get(
reverse('documents_folder_edit', args=[self.folder.id]))
self.assertEquals(response.status_code, 200)
def test_folder_delete_login(self):
"Test index page with login at /documents/folder/delete/<folder_id>"
response = self.client.post('/accounts/login', {
'username': self.username,
'password': self.password
})
self.assertRedirects(response, '/')
response = self.client.get(
reverse('documents_folder_delete', args=[self.folder.id]))
self.assertEquals(response.status_code, 200)
# Documents
def test_document_add(self):
"Test index page with login at /documents/add"
response = self.client.post('/accounts/login', {
'username': self.username,
'password': self.password
})
self.assertRedirects(response, '/')
response = self.client.get(reverse('documents_document_add'))
self.assertEquals(response.status_code, 200)
# form
self.assertEqual(Document.objects.count(), 1)
response = self.client.get(reverse('documents_document_add'))
post_data = {
'title': 'test',
'folder': self.folder,
}
response = self.client.post(reverse('documents_document_add'),
post_data)
#self.assertEqual(Document.objects.count(), 2)
def test_document_add_typed(self):
"Test index page with login at /documents/add/folder/<folder_id>"
response = self.client.post('/accounts/login', {
'username': self.username,
'password': self.password
})
self.assertRedirects(response, '/')
response = self.client.get(
reverse('documents_document_add_typed', args=[self.folder.id]))
self.assertEquals(response.status_code, 200)
def test_document_view_login(self):
"Test index page with login at /documents/view/<document_id>"
response = self.client.post('/accounts/login', {
'username': self.username,
'password': self.password
})
self.assertRedirects(response, '/')
response = self.client.get(
reverse('documents_document_view', args=[self.document.id]))
self.assertEquals(response.status_code, 200)
def test_document_edit_login(self):
"Test index page with login at /documents/edit/<document_id>"
response = self.client.post('/accounts/login', {
'username': self.username,
'password': self.password
})
self.assertRedirects(response, '/')
response = self.client.get(
reverse('documents_document_edit', args=[self.document.id]))
self.assertEquals(response.status_code, 200)
def test_document_delete_login(self):
"Test index page with login at /documents/delete/<document_id>"
response = self.client.post('/accounts/login', {
'username': self.username,
'password': self.password
})
self.assertRedirects(response, '/')
response = self.client.get(
reverse('documents_document_delete', args=[self.document.id]))
self.assertEquals(response.status_code, 200)
# Files
def test_file_view_login(self):
"Test index page with login at /file/view/<file_id>"
response = self.client.post('/accounts/login', {
'username': self.username,
'password': self.password
})
self.assertRedirects(response, '/')
response = self.client.get(
reverse('documents_file_view', args=[self.file.id]))
self.assertEquals(response.status_code, 200)
def test_file_edit_login(self):
"Test index page with login at /file/edit/<file_id>"
response = self.client.post('/accounts/login', {
'username': self.username,
'password': self.password
})
self.assertRedirects(response, '/')
response = self.client.get(
reverse('documents_file_edit', args=[self.file.id]))
self.assertEquals(response.status_code, 200)
def test_file_delete_login(self):
"Test index page with login at /file/view/<file_id>"
response = self.client.post('/accounts/login', {
'username': self.username,
'password': self.password
})
self.assertRedirects(response, '/')
response = self.client.get(
reverse('documents_file_delete', args=[self.file.id]))
self.assertEquals(response.status_code, 200)
# Web Links
def test_weblink_add_typed(self):
"Test index page with login at /documents/weblink/add/<folder_id>"
response = self.client.post('/accounts/login', {
'username': self.username,
'password': self.password
})
self.assertRedirects(response, '/')
response = self.client.get(
reverse('documents_weblink_add_typed', args=[self.folder.id]))
self.assertEquals(response.status_code, 200)
def test_weblink_add(self):
"Test index page with login at /documents/weblink/add/"
response = self.client.post('/accounts/login', {
'username': self.username,
'password': self.password
})
self.assertRedirects(response, '/')
response = self.client.get(reverse('documents_weblink_add'))
self.assertEquals(response.status_code, 200)
# form
self.assertEqual(WebLink.objects.count(), 1)
response = self.client.get(reverse('documents_weblink_add'))
post_data = {
'title': 'test',
'folder': self.folder,
'url': 'test',
}
response = self.client.post(reverse('documents_weblink_add'),
post_data)
#self.assertEqual(WebLink.objects.count(), 2)
def test_weblink_view_login(self):
"Test index page with login at /documents/view/<weblink_id>"
response = self.client.post('/accounts/login', {
'username': self.username,
'password': self.password
})
self.assertRedirects(response, '/')
response = self.client.get(
reverse('documents_weblink_view', args=[self.link.id]))
self.assertEquals(response.status_code, 200)
def test_weblink_edit_login(self):
"Test index page with login at /documents/edit/<weblink_id>"
response = self.client.post('/accounts/login', {
'username': self.username,
'password': self.password
})
self.assertRedirects(response, '/')
response = self.client.get(
reverse('documents_weblink_edit', args=[self.link.id]))
self.assertEquals(response.status_code, 200)
def test_weblink_delete_login(self):
"Test index page with login at /documents/delete/<weblink_id>"
response = self.client.post('/accounts/login', {
'username': self.username,
'password': self.password
})
self.assertRedirects(response, '/')
response = self.client.get(
reverse('documents_weblink_delete', args=[self.link.id]))
self.assertEquals(response.status_code, 200)
######################################
# Testing views when user is not logged in
######################################
def test_index(self):
"Test index page at /documents/"
response = self.client.get('/documents/')
# Redirects as unauthenticated
self.assertRedirects(response, reverse('user_login'))
def test_index_documents_out(self):
"Testing /documents/documents/"
response = self.client.get(reverse('index_documents'))
self.assertRedirects(response, reverse('user_login'))
def test_index_files_out(self):
"Testing /documents/files/"
response = self.client.get(reverse('index_files'))
self.assertRedirects(response, reverse('user_login'))
def test_index_weblinks_out(self):
"Testing /documents/weblinks/"
response = self.client.get(reverse('index_weblinks'))
self.assertRedirects(response, reverse('user_login'))
# Folders
def test_folder_add_out(self):
"Testing /documents/folder/add/"
response = self.client.get(reverse('documents_folder_add'))
self.assertRedirects(response, reverse('user_login'))
def test_folder_view_out(self):
"Testing /documents/folder/view/<folder_id>"
response = self.client.get(
reverse('documents_folder_view', args=[self.folder.id]))
self.assertRedirects(response, reverse('user_login'))
def test_folder_edit_out(self):
"Testing /documents/folder/edit/<folder_id>"
response = self.client.get(
reverse('documents_folder_edit', args=[self.folder.id]))
self.assertRedirects(response, reverse('user_login'))
def test_folder_delete_out(self):
"Testing /documents/folder/delete/<folder_id>"
response = self.client.get(
reverse('documents_folder_delete', args=[self.folder.id]))
self.assertRedirects(response, reverse('user_login'))
# Documents
def test_document_add_out(self):
"Testing /documents/add"
response = self.client.get(reverse('documents_document_add'))
self.assertRedirects(response, reverse('user_login'))
def test_document_add_typed_out(self):
"Testing /documents/add/folder/<folder_id>"
response = self.client.get(
reverse('documents_document_add_typed', args=[self.folder.id]))
self.assertRedirects(response, reverse('user_login'))
def test_document_view_out(self):
"Testing /documents/view/<document_id>"
response = self.client.get(
reverse('documents_document_view', args=[self.document.id]))
self.assertRedirects(response, reverse('user_login'))
def test_document_edit_out(self):
"Testing /documents/edit/<document_id>"
response = self.client.get(
reverse('documents_document_edit', args=[self.document.id]))
self.assertRedirects(response, reverse('user_login'))
def test_document_delete_out(self):
"Testing /documents/delete/<document_id>"
response = self.client.get(
reverse('documents_document_delete', args=[self.document.id]))
self.assertRedirects(response, reverse('user_login'))
# Files
def test_file_view_out(self):
"Testing /file/view/<file_id>"
response = self.client.get(
reverse('documents_file_view', args=[self.file.id]))
self.assertRedirects(response, reverse('user_login'))
def test_file_edit_out(self):
"Testing /file/edit/<file_id>"
response = self.client.get(
reverse('documents_file_edit', args=[self.file.id]))
self.assertRedirects(response, reverse('user_login'))
def test_file_delete_out(self):
"Testing /file/view/<file_id>"
response = self.client.get(
reverse('documents_file_delete', args=[self.file.id]))
self.assertRedirects(response, reverse('user_login'))
# Web Links
def test_weblink_add_typed_out(self):
"Testing /documents/weblink/add/<folder_id>"
response = self.client.get(
reverse('documents_weblink_add_typed', args=[self.folder.id]))
self.assertRedirects(response, reverse('user_login'))
def test_weblink_add_out(self):
"Testing /documents/weblink/add/"
response = self.client.get(reverse('documents_weblink_add'))
self.assertRedirects(response, reverse('user_login'))
def test_weblink_view_out(self):
"Testing /documents/view/<weblink_id>"
response = self.client.get(
reverse('documents_weblink_view', args=[self.link.id]))
self.assertRedirects(response, reverse('user_login'))
def test_weblink_edit_out(self):
"Testing /documents/edit/<weblink_id>"
response = self.client.get(
reverse('documents_weblink_edit', args=[self.link.id]))
self.assertRedirects(response, reverse('user_login'))
def test_weblink_delete_out(self):
"Testing /documents/delete/<weblink_id>"
response = self.client.get(
reverse('documents_weblink_delete', args=[self.link.id]))
self.assertRedirects(response, reverse('user_login'))
def setUp(self):
"Initial Setup"
if not self.prepared:
# Clean up first
Object.objects.all().delete()
User.objects.all().delete()
# Create objects
try:
self.group = Group.objects.get(name='api_test')
except Group.DoesNotExist:
Group.objects.all().delete()
self.group = Group(name='api_test')
self.group.save()
try:
self.user = DjangoUser.objects.get(username=self.username)
self.user.set_password(self.password)
try:
self.profile = self.user.get_profile()
except Exception:
User.objects.all().delete()
self.user = DjangoUser(username=self.username, password='')
self.user.set_password(self.password)
self.user.save()
except DjangoUser.DoesNotExist:
User.objects.all().delete()
self.user = DjangoUser(username=self.username, password='')
self.user.set_password(self.password)
self.user.save()
try:
perspective = Perspective.objects.get(name='default')
except Perspective.DoesNotExist:
Perspective.objects.all().delete()
perspective = Perspective(name='default')
perspective.set_default_user()
perspective.save()
ModuleSetting.set('default_perspective', perspective.id)
self.contact_type = ContactType(name='api_test')
self.contact_type.set_default_user()
self.contact_type.save()
self.contact = Contact(
name='api_test', contact_type=self.contact_type)
self.contact.set_default_user()
self.contact.save()
self.project = Project(
name='api_test', manager=self.contact, client=self.contact)
self.project.set_default_user()
self.project.save()
self.status = TaskStatus(name='api_test')
self.status.set_default_user()
self.status.save()
self.milestone = Milestone(
name='api_test', project=self.project, status=self.status)
self.milestone.set_default_user()
self.milestone.save()
self.task = Task(
name='api_test', project=self.project, status=self.status, priority=3)
self.task.set_default_user()
self.task.save()
self.time_slot = TaskTimeSlot(
task=self.task, details='api_test', time_from=datetime.now(), user=self.user.get_profile())
self.time_slot.set_default_user()
self.time_slot.save()
self.parent = Project(name='api_test')
self.parent.set_default_user()
self.parent.save()
self.parent_task = Task(
name='api_test', project=self.project, status=self.status, priority=3)
self.parent_task.set_default_user()
self.parent_task.save()
self.client = Client()
self.prepared = True
class KnowledgeViewsTest(TestCase):
"Knowledge functional tests for views"
username = "******"
password = "******"
prepared = False
authentication_headers ={"CONTENT_TYPE": "application/json",
"HTTP_AUTHORIZATION" : "Basic YXBpX3Rlc3Q6YXBpX3Bhc3N3b3Jk" }
content_type ='application/json'
prepared = False
def setUp(self):
"Initial Setup"
if not self.prepared:
# Clean up first
Object.objects.all().delete()
# Create objects
try:
self.group = Group.objects.get(name='test')
except Group.DoesNotExist:
Group.objects.all().delete()
self.group = Group(name='test')
self.group.save()
try:
self.user = DjangoUser.objects.get(username=self.username)
self.user.set_password(self.password)
try:
self.profile = self.user.get_profile()
except Exception:
User.objects.all().delete()
self.user = DjangoUser(username=self.username, password='')
self.user.set_password(self.password)
self.user.save()
except DjangoUser.DoesNotExist:
User.objects.all().delete()
self.user = DjangoUser(username=self.username, password='')
self.user.set_password(self.password)
self.user.save()
try:
perspective = Perspective.objects.get(name='default')
except Perspective.DoesNotExist:
Perspective.objects.all().delete()
perspective = Perspective(name='default')
perspective.set_default_user()
perspective.save()
ModuleSetting.set('default_perspective', perspective.id)
self.folder = KnowledgeFolder(name='test', treepath='test')
self.folder.set_default_user()
self.folder.save()
self.category = KnowledgeCategory(name='test', treepath='test')
self.category.set_default_user()
self.category.save()
self.item = KnowledgeItem(name='test', folder=self.folder,
category=self.category, treepath='test')
self.item.set_default_user()
self.item.save()
# parent folder
self.parent = KnowledgeFolder(name='test', treepath='test')
self.parent.set_default_user()
self.parent.save()
self.client = Client()
self.prepared = True
def test_unauthenticated_access(self):
"Test index page at /api/knowledge/folders"
response = self.client.get('/api/knowledge/folders')
# Redirects as unauthenticated
self.assertEquals(response.status_code, 401)
def test_get_folders_list(self):
""" Test index page api/knowledge/folders """
response = self.client.get(path=reverse('api_knowledge_folders'), **self.authentication_headers)
self.assertEquals(response.status_code, 200)
def test_get_folder(self):
response = self.client.get(path=reverse('api_knowledge_folders', kwargs={'object_ptr': self.folder.id}), **self.authentication_headers)
self.assertEquals(response.status_code, 200)
def test_update_folder(self):
updates = {'name': 'Api folder update', 'parent': self.parent.id, 'details': '<p>api details</p>'}
response = self.client.put(path=reverse('api_knowledge_folders', kwargs={'object_ptr': self.folder.id}),
content_type=self.content_type, data=json.dumps(updates), **self.authentication_headers)
self.assertEquals(response.status_code, 200)
data = json.loads(response.content)
self.assertEquals(updates["name"], data["name"])
self.assertEquals(updates["parent"], data["parent"]["id"])
self.assertEquals(updates["details"], data["details"])
def test_get_categories_list(self):
""" Test index page api/knowledge/categories """
response = self.client.get(path=reverse('api_knowledge_categories'), **self.authentication_headers)
self.assertEquals(response.status_code, 200)
def test_get_category(self):
response = self.client.get(path=reverse('api_knowledge_categories', kwargs={'object_ptr': self.category.id}), **self.authentication_headers)
self.assertEquals(response.status_code, 200)
def test_update_category(self):
updates = {'name': 'Api catagory update', 'details': '<p>api details</p>'}
response = self.client.put(path=reverse('api_knowledge_categories', kwargs={'object_ptr': self.category.id}),
content_type=self.content_type, data=json.dumps(updates), **self.authentication_headers)
self.assertEquals(response.status_code, 200)
data = json.loads(response.content)
self.assertEquals(updates["name"], data["name"])
self.assertEquals(updates["details"], data["details"])
def test_get_items_list(self):
""" Test index page api/knowledge/items """
response = self.client.get(path=reverse('api_knowledge_items'), **self.authentication_headers)
self.assertEquals(response.status_code, 200)
def test_get_item(self):
response = self.client.get(path=reverse('api_knowledge_items', kwargs={'object_ptr': self.item.id}), **self.authentication_headers)
self.assertEquals(response.status_code, 200)
def test_update_item(self):
updates = {'name': 'Api item update', 'folder': self.folder.id, 'category': self.category.id,
'body': '<p>api body</p>'}
response = self.client.put(path=reverse('api_knowledge_items', kwargs={'object_ptr': self.item.id}),
content_type=self.content_type, data=json.dumps(updates), **self.authentication_headers)
self.assertEquals(response.status_code, 400)
def setUp(self):
"Initial Setup"
if not self.prepared:
# Clean up first
Object.objects.all().delete()
User.objects.all().delete()
# Create objects
try:
self.group = Group.objects.get(name='test')
except Group.DoesNotExist:
Group.objects.all().delete()
self.group = Group(name='test')
self.group.save()
try:
self.user = DjangoUser.objects.get(username=self.username)
self.user.set_password(self.password)
try:
self.profile = self.user.get_profile()
except Exception:
User.objects.all().delete()
self.user = DjangoUser(username=self.username, password='')
self.user.set_password(self.password)
self.user.save()
except DjangoUser.DoesNotExist:
User.objects.all().delete()
self.user = DjangoUser(username=self.username, password='')
self.user.set_password(self.password)
self.user.save()
try:
perspective = Perspective.objects.get(name='default')
except Perspective.DoesNotExist:
Perspective.objects.all().delete()
perspective = Perspective(name='default')
perspective.set_user(self.user.get_profile())
perspective.save()
ModuleSetting.set('default_perspective', perspective.id)
self.contact_type = ContactType(name='test')
self.contact_type.set_default_user()
self.contact_type.save()
self.contact = Contact(name='test', contact_type=self.contact_type)
self.contact.set_default_user()
self.contact.save()
self.status = TicketStatus(name='TestStatus')
self.status.set_default_user()
self.status.save()
self.queue = TicketQueue(name='TestQueue',
default_ticket_status=self.status)
self.queue.set_default_user()
self.queue.save()
self.ticket = Ticket(name='TestTicket',
status=self.status,
queue=self.queue)
self.ticket.set_default_user()
self.ticket.save()
self.agent = ServiceAgent(related_user=self.user.get_profile(),
available_from=datetime.time(9),
available_to=datetime.time(17))
self.agent.set_default_user()
self.agent.save()
self.service = Service(name='test')
self.service.set_default_user()
self.service.save()
self.sla = ServiceLevelAgreement(name='test',
service=self.service,
client=self.contact,
provider=self.contact)
self.sla.set_default_user()
self.sla.save()
self.client = Client()
self.prepared = True
class ProjectsViewsTest(TestCase):
"Projects functional tests for views"
username = "******"
password = "******"
prepared = False
def setUp(self):
"Initial Setup"
if not self.prepared:
# Clean up first
Object.objects.all().delete()
User.objects.all().delete()
# Create objects
try:
self.group = Group.objects.get(name='test')
except Group.DoesNotExist:
Group.objects.all().delete()
self.group = Group(name='test')
self.group.save()
try:
self.user = DjangoUser.objects.get(username=self.username)
self.user.set_password(self.password)
try:
self.profile = self.user.get_profile()
except Exception:
User.objects.all().delete()
self.user = DjangoUser(username=self.username, password='')
self.user.set_password(self.password)
self.user.save()
except DjangoUser.DoesNotExist:
User.objects.all().delete()
self.user = DjangoUser(username=self.username, password='')
self.user.set_password(self.password)
self.user.save()
try:
perspective = Perspective.objects.get(name='default')
except Perspective.DoesNotExist:
Perspective.objects.all().delete()
perspective = Perspective(name='default')
perspective.set_default_user()
perspective.save()
ModuleSetting.set('default_perspective', perspective.id)
self.contact_type = ContactType(name='test')
self.contact_type.set_default_user()
self.contact_type.save()
self.contact = Contact(name='test', contact_type=self.contact_type)
self.contact.set_default_user()
self.contact.save()
self.project = Project(name='test',
manager=self.contact,
client=self.contact)
self.project.set_default_user()
self.project.save()
self.status = TaskStatus(name='test')
self.status.set_default_user()
self.status.save()
self.milestone = Milestone(name='test',
project=self.project,
status=self.status)
self.milestone.set_default_user()
self.milestone.save()
self.task = Task(name='test',
project=self.project,
status=self.status,
priority=3)
self.task.set_default_user()
self.task.save()
self.time_slot = TaskTimeSlot(task=self.task,
details='test',
time_from=datetime.now(),
user=self.user.get_profile())
self.time_slot.set_default_user()
self.time_slot.save()
self.parent = Project(name='test')
self.parent.set_default_user()
self.parent.save()
self.parent_task = Task(name='test',
project=self.project,
status=self.status,
priority=3)
self.parent_task.set_default_user()
self.parent_task.save()
self.client = Client()
self.prepared = True
######################################
# Testing views when user is logged in
######################################
def test_index_login(self):
"Test index page with login at /projects/"
response = self.client.post('/accounts/login', {
'username': self.username,
'password': self.password
})
self.assertRedirects(response, '/')
response = self.client.get(reverse('projects'))
self.assertEquals(response.status_code, 200)
# Projects
def test_project_add(self):
"Test index page with login at /projects/add/"
response = self.client.post('/accounts/login', {
'username': self.username,
'password': self.password
})
self.assertRedirects(response, '/')
response = self.client.get(reverse('project_add'))
self.assertEquals(response.status_code, 200)
def test_project_add_typed(self):
"Test index page with login at /projects/add/<project_id>/"
response = self.client.post('/accounts/login', {
'username': self.username,
'password': self.password
})
self.assertRedirects(response, '/')
response = self.client.get(
reverse('projects_project_add_typed', args=[self.parent.id]))
self.assertEquals(response.status_code, 200)
def test_project_view_login(self):
"Test index page with login at /projects/view/<project_id>"
response = self.client.post('/accounts/login', {
'username': self.username,
'password': self.password
})
self.assertRedirects(response, '/')
response = self.client.get(
reverse('projects_project_view', args=[self.project.id]))
self.assertEquals(response.status_code, 200)
def test_project_edit_login(self):
"Test index page with login at /projects/edit//<project_id>"
response = self.client.post('/accounts/login', {
'username': self.username,
'password': self.password
})
self.assertRedirects(response, '/')
response = self.client.get(
reverse('projects_project_edit', args=[self.project.id]))
self.assertEquals(response.status_code, 200)
def test_project_delete_login(self):
"Test index page with login at /projects/delete//<project_id>"
response = self.client.post('/accounts/login', {
'username': self.username,
'password': self.password
})
self.assertRedirects(response, '/')
response = self.client.get(
reverse('projects_project_delete', args=[self.project.id]))
self.assertEquals(response.status_code, 200)
# Milestones
def test_milestone_add(self):
"Test index page with login at /projects/milestone/add"
response = self.client.post('/accounts/login', {
'username': self.username,
'password': self.password
})
self.assertRedirects(response, '/')
response = self.client.get(reverse('projects_milestone_add'))
self.assertEquals(response.status_code, 200)
def test_milestone_add_typed(self):
"Test index page with login at /projects/milestone/add/<project_id>"
response = self.client.post('/accounts/login', {
'username': self.username,
'password': self.password
})
self.assertRedirects(response, '/')
response = self.client.get(
reverse('projects_milestone_add_typed', args=[self.parent.id]))
self.assertEquals(response.status_code, 200)
def test_milestone_view_login(self):
"Test index page with login at /projects/milestone/view/<milestone_id>"
response = self.client.post('/accounts/login', {
'username': self.username,
'password': self.password
})
self.assertRedirects(response, '/')
response = self.client.get(
reverse('projects_milestone_view', args=[self.milestone.id]))
self.assertEquals(response.status_code, 200)
def test_milestone_edit_login(self):
"Test index page with login at /projects/milestone/edit/<milestone_id>"
response = self.client.post('/accounts/login', {
'username': self.username,
'password': self.password
})
self.assertRedirects(response, '/')
response = self.client.get(
reverse('projects_milestone_edit', args=[self.milestone.id]))
self.assertEquals(response.status_code, 200)
def test_milestone_delete_login(self):
"Test index page with login at /projects/milestone/delete/<milestone_id>"
response = self.client.post('/accounts/login', {
'username': self.username,
'password': self.password
})
self.assertRedirects(response, '/')
response = self.client.get(
reverse('projects_milestone_delete', args=[self.milestone.id]))
self.assertEquals(response.status_code, 200)
# Tasks
def test_task_add(self):
"Test index page with login at /projects/task/add/"
response = self.client.post('/accounts/login', {
'username': self.username,
'password': self.password
})
self.assertRedirects(response, '/')
response = self.client.get(reverse('projects_task_add'))
self.assertEquals(response.status_code, 200)
def test_task_add_typed(self):
"Test index page with login at /projects/task/add/<project_id>"
response = self.client.post('/accounts/login', {
'username': self.username,
'password': self.password
})
self.assertRedirects(response, '/')
response = self.client.get(
reverse('projects_task_add_typed', args=[self.project.id]))
self.assertEquals(response.status_code, 200)
def test_task_add_to_milestone(self):
"Test index page with login at /projects/task/add/<milestone_id>"
response = self.client.post('/accounts/login', {
'username': self.username,
'password': self.password
})
self.assertRedirects(response, '/')
response = self.client.get(
reverse('projects_task_add_to_milestone',
args=[self.milestone.id]))
self.assertEquals(response.status_code, 200)
def test_task_add_subtask(self):
"Test index page with login at /projects/task/add/<task_id>/"
response = self.client.post('/accounts/login', {
'username': self.username,
'password': self.password
})
self.assertRedirects(response, '/')
response = self.client.get(
reverse('projects_task_add_subtask', args=[self.parent_task.id]))
self.assertEquals(response.status_code, 200)
def test_task_set_status(self):
"Test index page with login at /projects/task/add/<task_id>/status/<status_id>"
response = self.client.post('/accounts/login', {
'username': self.username,
'password': self.password
})
self.assertRedirects(response, '/')
response = self.client.get(
reverse('projects_task_set_status',
args=[self.task.id, self.status.id]))
self.assertEquals(response.status_code, 200)
def test_task_view_login(self):
"Test index page with login at /projects/task/view/<task_id>"
response = self.client.post('/accounts/login', {
'username': self.username,
'password': self.password
})
self.assertRedirects(response, '/')
response = self.client.get(
reverse('projects_task_view', args=[self.task.id]))
self.assertEquals(response.status_code, 200)
def test_task_edit_login(self):
"Test index page with login at /projects/task/edit/<task_id>"
response = self.client.post('/accounts/login', {
'username': self.username,
'password': self.password
})
self.assertRedirects(response, '/')
response = self.client.get(
reverse('projects_task_edit', args=[self.task.id]))
self.assertEquals(response.status_code, 200)
def test_task_delete_login(self):
"Test index page with login at /projects/task/delete/<task_id>"
response = self.client.post('/accounts/login', {
'username': self.username,
'password': self.password
})
self.assertRedirects(response, '/')
response = self.client.get(
reverse('projects_task_delete', args=[self.task.id]))
self.assertEquals(response.status_code, 200)
# Task Time Slots
def test_time_slot_add(self):
"Test index page with login at /projects/task/view/time/<task_id>add/"
response = self.client.post('/accounts/login', {
'username': self.username,
'password': self.password
})
self.assertRedirects(response, '/')
response = self.client.get(
reverse('projects_task_time_slot_add', args=[self.task.id]))
self.assertEquals(response.status_code, 200)
def test_time_slot_view_login(self):
"Test index page with login at /projects/task/view/time/<time_slot_id>"
response = self.client.post('/accounts/login', {
'username': self.username,
'password': self.password
})
self.assertRedirects(response, '/')
response = self.client.get(
reverse('projects_task_view', args=[self.task.id]))
self.assertEquals(response.status_code, 200)
def test_time_slot_edit_login(self):
"Test index page with login at /projects/task/edit/time/<time_slot_id>"
response = self.client.post('/accounts/login', {
'username': self.username,
'password': self.password
})
self.assertRedirects(response, '/')
response = self.client.get(
reverse('projects_task_edit', args=[self.task.id]))
self.assertEquals(response.status_code, 200)
def test_time_slot_delete_login(self):
"Test index page with login at /projects/task/delete/time/<time_slot_id>"
response = self.client.post('/accounts/login', {
'username': self.username,
'password': self.password
})
self.assertRedirects(response, '/')
response = self.client.get(
reverse('projects_task_delete', args=[self.task.id]))
self.assertEquals(response.status_code, 200)
# Task Statuses
def test_task_status_add(self):
"Test index page with login at /projects/task/status/add/"
response = self.client.post('/accounts/login', {
'username': self.username,
'password': self.password
})
self.assertRedirects(response, '/')
response = self.client.get(reverse('projects_task_status_add'))
self.assertEquals(response.status_code, 200)
def test_task_status_view_login(self):
"Test index page with login at /projects/task/status/view/<status_id>/"
response = self.client.post('/accounts/login', {
'username': self.username,
'password': self.password
})
self.assertRedirects(response, '/')
response = self.client.get(
reverse('projects_index_by_status', args=[self.status.id]))
self.assertEquals(response.status_code, 200)
def test_task_status_edit_login(self):
"Test index page with login at /projects/task/status/edit/<status_id>/"
response = self.client.post('/accounts/login', {
'username': self.username,
'password': self.password
})
self.assertRedirects(response, '/')
response = self.client.get(
reverse('projects_task_status_edit', args=[self.status.id]))
self.assertEquals(response.status_code, 200)
def test_task_status_delete_login(self):
"Test index page with login at /projects/task/status/delete/<status_id>/"
response = self.client.post('/accounts/login', {
'username': self.username,
'password': self.password
})
self.assertRedirects(response, '/')
response = self.client.get(
reverse('projects_task_status_delete', args=[self.status.id]))
self.assertEquals(response.status_code, 200)
# Settings
def test_project_settings_view(self):
"Test index page with login at /projects/settings/view/"
response = self.client.post('/accounts/login', {
'username': self.username,
'password': self.password
})
self.assertRedirects(response, '/')
response = self.client.get(reverse('projects_settings_view'))
self.assertEquals(response.status_code, 200)
def test_project_settings_edit(self):
"Test index page with login at /projects/settings/edit/"
response = self.client.post('/accounts/login', {
'username': self.username,
'password': self.password
})
self.assertRedirects(response, '/')
response = self.client.get(reverse('projects_settings_edit'))
self.assertEquals(response.status_code, 200)
######################################
# Testing views when user is not logged in
######################################
def test_index(self):
"Test index page at /projects/"
response = self.client.get('/projects/')
# Redirects as unauthenticated
self.assertRedirects(response, reverse('user_login'))
# Projects
def test_project_add_out(self):
"Testing /projects/add/"
response = self.client.get(reverse('project_add'))
self.assertRedirects(response, reverse('user_login'))
def test_project_add_typed_out(self):
"Testing /projects/add/<project_id>/"
response = self.client.get(
reverse('projects_project_add_typed', args=[self.parent.id]))
self.assertRedirects(response, reverse('user_login'))
def test_project_view_out(self):
"Testing /projects/view/<project_id>"
response = self.client.get(
reverse('projects_project_view', args=[self.project.id]))
self.assertRedirects(response, reverse('user_login'))
def test_project_edit_out(self):
"Testing /projects/edit//<project_id>"
response = self.client.get(
reverse('projects_project_edit', args=[self.project.id]))
self.assertRedirects(response, reverse('user_login'))
def test_project_delete_out(self):
"Testing /projects/delete//<project_id>"
response = self.client.get(
reverse('projects_project_delete', args=[self.project.id]))
self.assertRedirects(response, reverse('user_login'))
# Milestones
def test_milestone_add_out(self):
"Testing /projects/milestone/add"
response = self.client.get(reverse('projects_milestone_add'))
self.assertRedirects(response, reverse('user_login'))
def test_milestone_add_typed_out(self):
"Testing /projects/milestone/add/<project_id>"
response = self.client.get(
reverse('projects_milestone_add_typed', args=[self.parent.id]))
self.assertRedirects(response, reverse('user_login'))
def test_milestone_view_out(self):
"Testing /projects/milestone/view/<milestone_id>"
response = self.client.get(
reverse('projects_milestone_view', args=[self.milestone.id]))
self.assertRedirects(response, reverse('user_login'))
def test_milestone_edit_out(self):
"Testing /projects/milestone/edit/<milestone_id>"
response = self.client.get(
reverse('projects_milestone_edit', args=[self.milestone.id]))
self.assertRedirects(response, reverse('user_login'))
def test_milestone_delete_out(self):
"Testing /projects/milestone/delete/<milestone_id>"
response = self.client.get(
reverse('projects_milestone_delete', args=[self.milestone.id]))
self.assertRedirects(response, reverse('user_login'))
# Tasks
def test_task_add_out(self):
"Testing /projects/task/add/"
response = self.client.get(reverse('projects_task_add'))
self.assertRedirects(response, reverse('user_login'))
def test_task_add_typed_out(self):
"Testing /projects/task/add/<project_id>"
response = self.client.get(
reverse('projects_task_add_typed', args=[self.project.id]))
self.assertRedirects(response, reverse('user_login'))
def test_task_add_to_milestone_out(self):
"Testing /projects/task/add/<milestone_id>"
response = self.client.get(
reverse('projects_task_add_to_milestone',
args=[self.milestone.id]))
self.assertRedirects(response, reverse('user_login'))
def test_task_add_subtask_out(self):
"Testing /projects/task/add/<task_id>/"
response = self.client.get(
reverse('projects_task_add_subtask', args=[self.parent_task.id]))
self.assertRedirects(response, reverse('user_login'))
def test_task_set_status_out(self):
"Testing /projects/task/add/<task_id>/status/<status_id>"
response = self.client.get(
reverse('projects_task_set_status',
args=[self.task.id, self.status.id]))
self.assertRedirects(response, reverse('user_login'))
def test_task_view_out(self):
"Testing /projects/task/view/<task_id>"
response = self.client.get(
reverse('projects_task_view', args=[self.task.id]))
self.assertRedirects(response, reverse('user_login'))
def test_task_edit_out(self):
"Testing /projects/task/edit/<task_id>"
response = self.client.get(
reverse('projects_task_edit', args=[self.task.id]))
self.assertRedirects(response, reverse('user_login'))
def test_task_delete_out(self):
"Testing /projects/task/delete/<task_id>"
response = self.client.get(
reverse('projects_task_delete', args=[self.task.id]))
self.assertRedirects(response, reverse('user_login'))
# Task Time Slots
def test_time_slot_add_out(self):
"Testing /projects/task/view/time/<task_id>add/"
response = self.client.get(
reverse('projects_task_time_slot_add', args=[self.task.id]))
self.assertRedirects(response, reverse('user_login'))
def test_time_slot_view_out(self):
"Testing /projects/task/view/time/<time_slot_id>"
response = self.client.get(
reverse('projects_task_view', args=[self.task.id]))
self.assertRedirects(response, reverse('user_login'))
def test_time_slot_edit_out(self):
"Testing /projects/task/edit/time/<time_slot_id>"
response = self.client.get(
reverse('projects_task_edit', args=[self.task.id]))
self.assertRedirects(response, reverse('user_login'))
def test_time_slot_delete_out(self):
"Testing /projects/task/delete/time/<time_slot_id>"
response = self.client.get(
reverse('projects_task_delete', args=[self.task.id]))
self.assertRedirects(response, reverse('user_login'))
# Task Statuses
def test_task_status_add_out(self):
"Testing /projects/task/status/add/"
response = self.client.get(reverse('projects_task_status_add'))
self.assertRedirects(response, reverse('user_login'))
def test_task_status_view_out(self):
"Testing /projects/task/status/view/<status_id>/"
response = self.client.get(
reverse('projects_index_by_status', args=[self.status.id]))
self.assertRedirects(response, reverse('user_login'))
def test_task_status_edit_out(self):
"Testing /projects/task/status/edit/<status_id>/"
response = self.client.get(
reverse('projects_task_status_edit', args=[self.status.id]))
self.assertRedirects(response, reverse('user_login'))
def test_task_status_delete_out(self):
"Testing /projects/task/status/delete/<status_id>/"
response = self.client.get(
reverse('projects_task_status_delete', args=[self.status.id]))
self.assertRedirects(response, reverse('user_login'))
# Settings
def test_project_settings_view_out(self):
"Testing /projects/settings/view/"
response = self.client.get(reverse('projects_settings_view'))
self.assertRedirects(response, reverse('user_login'))
def test_project_settings_edit_out(self):
"Testing /projects/settings/edit/"
response = self.client.get(reverse('projects_settings_edit'))
self.assertRedirects(response, reverse('user_login'))
def setUp(self):
"Initial Setup"
if not self.prepared:
# Clean up first
Object.objects.all().delete()
User.objects.all().delete()
# Create objects
try:
self.group = Group.objects.get(name='test')
except Group.DoesNotExist:
Group.objects.all().delete()
self.group = Group(name='test')
self.group.save()
try:
self.user = DjangoUser.objects.get(username=self.username)
self.user.set_password(self.password)
try:
self.profile = self.user.get_profile()
except Exception:
User.objects.all().delete()
self.user = DjangoUser(username=self.username, password='')
self.user.set_password(self.password)
self.user.save()
except DjangoUser.DoesNotExist:
User.objects.all().delete()
self.user = DjangoUser(username=self.username, password='')
self.user.set_password(self.password)
self.user.save()
try:
perspective = Perspective.objects.get(name='default')
except Perspective.DoesNotExist:
Perspective.objects.all().delete()
perspective = Perspective(name='default')
perspective.set_default_user()
perspective.save()
ModuleSetting.set('default_perspective', perspective.id)
self.contact_type = ContactType(name='test')
self.contact_type.set_default_user()
self.contact_type.save()
self.contact = Contact(name='test', contact_type=self.contact_type)
self.contact.set_default_user()
self.contact.save()
self.category = Category(name='test')
self.category.set_default_user()
self.category.save()
self.equity = Equity(
issue_price=10, sell_price=10, issuer=self.contact, owner=self.contact)
self.equity.set_default_user()
self.equity.save()
self.asset = Asset(name='test', owner=self.contact)
self.asset.set_default_user()
self.asset.save()
self.tax = Tax(name='test', rate=10)
self.tax.set_default_user()
self.tax.save()
self.currency = Currency(code="GBP",
name="Pounds",
symbol="L",
is_default=True)
self.currency.set_default_user()
self.currency.save()
self.account = Account(
name='test', owner=self.contact, balance_currency=self.currency)
self.account.set_default_user()
self.account.save()
self.liability = Liability(name='test',
source=self.contact,
target=self.contact,
account=self.account,
value=10,
value_currency=self.currency)
self.liability.set_default_user()
self.liability.save()
self.transaction = Transaction(name='test', account=self.account, source=self.contact,
target=self.contact, value=10, value_currency=self.currency)
self.transaction.set_default_user()
self.transaction.save()
self.client = Client()
self.prepared = True
def setUp(self):
"Initial Setup"
if not self.prepared:
# Clean up first
Object.objects.all().delete()
User.objects.all().delete()
# Create objects
try:
self.group = Group.objects.get(name='test')
except Group.DoesNotExist:
Group.objects.all().delete()
self.group = Group(name='test')
self.group.save()
try:
self.user = DjangoUser.objects.get(username=self.username)
self.user.set_password(self.password)
try:
self.profile = self.user.get_profile()
except Exception:
User.objects.all().delete()
self.user = DjangoUser(username=self.username, password='')
self.user.set_password(self.password)
self.user.save()
except DjangoUser.DoesNotExist:
User.objects.all().delete()
self.user = DjangoUser(username=self.username, password='')
self.user.set_password(self.password)
self.user.save()
try:
perspective = Perspective.objects.get(name='default')
except Perspective.DoesNotExist:
Perspective.objects.all().delete()
perspective = Perspective(name='default')
perspective.set_default_user()
perspective.save()
ModuleSetting.set('default_perspective', perspective.id)
self.contact_type = ContactType(name='test')
self.contact_type.set_default_user()
self.contact_type.save()
self.contact = Contact(name='test', contact_type=self.contact_type)
self.contact.set_default_user()
self.contact.save()
self.project = Project(name='test',
manager=self.contact,
client=self.contact)
self.project.set_default_user()
self.project.save()
self.status = TaskStatus(name='test')
self.status.set_default_user()
self.status.save()
self.milestone = Milestone(name='test',
project=self.project,
status=self.status)
self.milestone.set_default_user()
self.milestone.save()
self.task = Task(name='test',
project=self.project,
status=self.status,
priority=3)
self.task.set_default_user()
self.task.save()
self.time_slot = TaskTimeSlot(task=self.task,
details='test',
time_from=datetime.now(),
user=self.user.get_profile())
self.time_slot.set_default_user()
self.time_slot.save()
self.parent = Project(name='test')
self.parent.set_default_user()
self.parent.save()
self.parent_task = Task(name='test',
project=self.project,
status=self.status,
priority=3)
self.parent_task.set_default_user()
self.parent_task.save()
self.client = Client()
self.prepared = True
