예제 #1
0
파일: tests.py 프로젝트: alejo8591/maker
 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()
예제 #2
0
파일: tests.py 프로젝트: alejo8591/maker
    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
예제 #3
0
파일: tests.py 프로젝트: alejo8591/maker
    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
예제 #4
0
파일: tests.py 프로젝트: alejo8591/maker
    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
예제 #5
0
파일: tests.py 프로젝트: alejo8591/maker
    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
예제 #6
0
파일: views.py 프로젝트: alejo8591/maker
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,
    )
예제 #7
0
파일: tests.py 프로젝트: alejo8591/maker
    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
예제 #8
0
파일: tests.py 프로젝트: alejo8591/maker
    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
예제 #9
0
파일: tests.py 프로젝트: alejo8591/maker
    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
예제 #10
0
파일: tests.py 프로젝트: alejo8591/maker
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'))
예제 #11
0
파일: tests.py 프로젝트: alejo8591/maker
    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
예제 #12
0
파일: tests.py 프로젝트: alejo8591/maker
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'])
예제 #13
0
파일: tests.py 프로젝트: alejo8591/maker
    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
예제 #14
0
파일: tests.py 프로젝트: alejo8591/maker
    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