def test_model_perspective(self):
"Test Perspective model"
obj = Perspective(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:
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 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:
# 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:
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 perspective_add(request, response_format="html"):
"Perspective add"
if request.POST:
if not "cancel" in request.POST:
perspective = Perspective()
form = PerspectiveForm(request.user.get_profile(), request.POST, instance=perspective)
if form.is_valid():
perspective = form.save()
perspective.set_user_from_request(request)
return HttpResponseRedirect(reverse("core_admin_perspective_view", args=[perspective.id]))
else:
return HttpResponseRedirect(reverse("core_admin_index_perspectives"))
else:
form = PerspectiveForm(request.user.get_profile())
return render_to_response(
"core/administration/perspective_add",
{"form": form.as_ul()},
context_instance=RequestContext(request),
response_format=response_format,
)
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 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()
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 CoreViewsTest(TestCase):
"Core View tests"
username = "******"
password = "******"
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()
self.perspective = Perspective(name='test')
self.perspective.set_default_user()
self.perspective.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'))
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 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_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()
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