django.contrib.auth.models.Group.objects.create

Here are the examples of the python api django.contrib.auth.models.Group.objects.create taken from open source projects. By voting up you can indicate which examples are most useful and appropriate.

148 Examples 7

Example 1

Project: django-cms Source File: test_permmod.py
Function: set_up
    def setUp(self):
        super(RestrictedViewPermissionTests, self).setUp()
        self.group = Group.objects.create(name='testgroup')
        self.pages = [self.page]
        self.expected = [self.page.pk]
        PagePermission.objects.create(page=self.page, group=self.group, can_view=True, grant_on=ACCESS_PAGE)

Example 2

Project: akvo-rsr Source File: test_map_locations.py
    def setUp(self):
        """Setup test cast.

        1. Create user
        2. Create auth group for REST API access
        3. Add the user to the created group
        4. Save a test Client with the correct HOST(needed because of our dispatch middleware)
        """
        u = User.objects.create(username="testuser", password="password", is_staff=True,
                                is_active=True, is_superuser=True)
        u.save()
        API_users = Group.objects.create(id=8, name="Full REST API access")
        API_users.save()
        API_users.user_set.add(u)
        self.c = Client(HTTP_HOST=settings.RSR_DOMAIN)

Example 3

Project: django-autocomplete-light Source File: test_forms.py
Function: test_save
    def test_save(self):
        m0 = self.model.objects.create(name=self.id())
        m1 = Group.objects.create(name=self.id())

        form = self.form(http.QueryDict('name=%s&test=%s&test=%s' % (
            self.id(), self.get_value(m0), self.get_value(m1))))
        expected = [m0, m1]

        instance = form.save()

        self.assert_relation_equals(expected, instance.test.all())
        self.assert_relation_equals(
            expected,
            self.model.objects.get(pk=instance.pk).test.all(),
        )

Example 4

Project: django-rules Source File: __init__.py
Function: setup_package
def setup_package():
    adrian = User.objects.create_user('adrian', password='secr3t')
    adrian.is_staff = True
    adrian.save()

    martin = User.objects.create_user('martin', password='secr3t')
    martin.is_staff = True
    martin.save()

    editors = Group.objects.create(name='editors')
    martin.groups.add(editors)

    Book.objects.create(
        isbn=ISBN,
        title='The Definitive Guide to Django',
        author=adrian)

Example 5

Project: hue Source File: tests_api.py
Function: set_up
  def setUp(self):
    self.client = make_logged_in_client(username="hue_test_admin", groupname="hue_test_admin", recreate=True, is_superuser=True)
    self.user = User.objects.get(username="hue_test_admin")

    self.non_superuser_client = make_logged_in_client(username="hue_test_user", groupname="hue_test_user", recreate=True, is_superuser=False)
    self.non_superuser = User.objects.get(username="hue_test_user")

    self.test_group = Group.objects.create(name="hue_test_group")
    self.non_superuser.groups.add(self.test_group)
    self.non_superuser.save()

Example 6

Project: wagtail Source File: test_account_management.py
Function: set_up
    def setUp(self):
        # Create a non-moderator user
        admin_only_group = Group.objects.create(name='Admin Only')
        admin_only_group.permissions.add(Permission.objects.get(codename='access_admin'))

        self.admin_only_user = get_user_model().objects.create_user(
            'admin_only_user',
            '[email protected]',
            'password'
        )
        self.admin_only_user.groups.add(admin_only_group)

        self.assertTrue(self.client.login(username=self.admin_only_user.username, password='password'))

Example 7

Project: editorsnotes-server Source File: models.py
    def create_project_role(self, project, role, **kwargs):
        """
        Create a project role & related group by the role name.
        """
        group_name = '{}-{}'.format(project.slug, role)
        role_group = Group.objects.create(name=group_name)
        return self.create(project=project, role=role, group=role_group,
                           **kwargs)

Example 8

Project: amy Source File: 0039_add_permission_groups.py
def add_permission_groups(apps, schema_editor):
    # create 'administrators' group with all permissions for CRUD
    auth_ct = ContentType.objects.get_for_models(Permission, Group)
    workshops_ct = ContentType.objects.get_for_models(
        Airport, Award, Badge, Event, Organization, KnowledgeDomain, Lesson, Person,
        Qualification, Role, Tag, Task,
    )
    auth_ct.update(workshops_ct)
    permissions = Permission.objects.filter(content_type__in=auth_ct.values())

    group = Group.objects.create(name='administrators')
    group.permissions = permissions
    group.save()

    # create 'steering committee' group, but don't grant any permissions (cause
    # read-only access doesn't require any)
    Group.objects.create(name='steering committee')

Example 9

Project: django-usertools Source File: tests.py
    def testGroupChangeList(self):
        # Create a group.
        group = Group.objects.create(
            name = "Foo group",
        )
        changelist_url = reverse("admin:auth_group_changelist")
        # Check the groups is present in the change list.
        response = self.client.get(changelist_url)
        self.assertContains(response, "Foo group")
        self.assertContains(response, ">0</td>")
        # Add a user, and check that the member count has increased.
        self.user.groups.add(group)
        response = self.client.get(changelist_url)
        self.assertContains(response, "Foo group")
        self.assertContains(response, ">1</td>")

Example 10

Project: portal Source File: test_models.py
    def test_join_group(self):
        """Test SystersUser joining an auth Group"""
        group = Group.objects.create(name="Baz")
        self.assertSequenceEqual(self.systers_user.user.groups.all(), [])
        self.systers_user.join_group(group)
        self.assertEqual(self.systers_user.user.groups.get(), group)

Example 11

Project: storybase Source File: __init__.py
Function: set_up
    def setUp(self):
        self.username = 'test'
        self.password = 'test'
        self.user = User.objects.create_user(self.username, 
            '[email protected]', self.password)
        self.admin_group = Group.objects.create(name=ADMIN_GROUP_NAME)
        self.admin = User.objects.create(username='admin', 
            password='password', email='[email protected]')
        self.admin.groups.add(self.admin_group)

Example 12

Project: django-affect Source File: utils_tests.py
    def test_user_in_groups(self):
        self.request.user = User.objects.create(
            username='test_user')
        group = Group.objects.create(name='test_group')
        self.request.user.groups.add(group)
        self.crit.groups.add(group)
        self.mock.StubOutWithMock(utils, 'cache_criteria')
        utils.cache_criteria(instance=self.crit)  # criteria
        utils.cache_criteria(instance=self.crit)  # users
        utils.cache_criteria(instance=self.crit)  # group

        self.mock.ReplayAll()
        self.assertIs(
            meets_criteria(self.request, 'test_crit'), True)
        self.mock.VerifyAll()

Example 13

Project: portal Source File: test_views.py
    def test_user_panel_permissions(self):
        """Test permissions panel from UserView"""
        self.client.login(username='foo', password='foobar')
        user_url = reverse('user', kwargs={
            'username': self.systers_user.user.username})
        response = self.client.get(user_url)
        self.assertContains(response, "Looks like you have no permissions.")
        self.assertTemplateUsed(response, 'users/view_profile.html')
        self.assertTemplateUsed(response, 'users/snippets/permissions.html')
        group = Group.objects.create(name="Bar")
        self.systers_user.user.groups.add(group)
        response = self.client.get(user_url)
        self.assertContains(response, "Bar")

Example 14

Project: django-permissions Source File: tests.py
Function: set_up
    def setUp(self):
        """
        """
        self.role_1 = permissions.utils.register_role("Role 1")
        self.role_2 = permissions.utils.register_role("Role 2")

        self.user = User.objects.create(username="john")
        self.group = Group.objects.create(name="brights")

        self.user.groups.add(self.group)

        self.page_1 = FlatPage.objects.create(url="/page-1/", title="Page 1")
        self.page_2 = FlatPage.objects.create(url="/page-1/", title="Page 2")

Example 15

Project: orchestra Source File: test_project_management_api.py
    def setUp(self):
        super().setUp()
        setup_models(self)
        self.project_admin_group = Group.objects.create(name='project_admins')
        user = (UserFactory(username='project_management',
                            first_name='project_management',
                            last_name='project_management',
                            password='project_management',
                            email='[email protected]'))
        self.worker = WorkerFactory(user=user)
        user.groups.add(self.project_admin_group)

        self.api_client = Client()
        self.api_client.login(
            username='project_management', password='project_management')

Example 16

Project: django-permission-backend-nonrel Source File: tests.py
Function: test_add_user_to_group
    def test_add_user_to_group(self):
        user = User.objects.get(username='test')
        group = Group.objects.create(name='test_group')
        update_user_groups(user, [group])
        self.assertEqual(UserPermissionList.objects.count(), 1)
        self.assertNotEqual(UserPermissionList.objects.all()[0] , None)

Example 17

Project: hawkpost Source File: tests.py
    def test_send_when_group_is_defined(self):
        settings.CELERY_ALWAYS_EAGER = True
        for i in range(4):
            create_and_login_user(self.client)
        last_user = create_and_login_user(self.client)
        group = Group.objects.create(name="Test Group")
        group.user_set.add(last_user)
        notification = create_notification(sent=False, group=group)
        enqueue_email_notifications(notification.id, notification.send_to.id)
        self.assertEqual(len(mail.outbox), 1)

Example 18

Project: edx-platform Source File: test_manage_user.py
Function: test_groups
    @ddt.data(*itertools.product(('', 'a', 'ab', 'abc'), repeat=2))
    @ddt.unpack
    def test_groups(self, initial_groups, expected_groups):
        """
        Ensures groups assignments are created and deleted idempotently.
        """
        groups = {}
        for group_name in 'abc':
            groups[group_name] = Group.objects.create(name=group_name)

        user = User.objects.create(username=TEST_USERNAME, email=TEST_EMAIL)
        for group_name in initial_groups:
            user.groups.add(groups[group_name])

        call_command('manage_user', TEST_USERNAME, TEST_EMAIL, '-g', *expected_groups)
        actual_groups = [group.name for group in user.groups.all()]
        self.assertEqual(actual_groups, list(expected_groups))

Example 19

Project: django-sharing Source File: tests.py
Function: set_up
    def setUp(self):
        # Create test object, users and groups.
        self.obj = TestModel.objects.create(id=1)
        self.user = User.objects.create(username='user')
        self.group = Group.objects.create(name='group')
        self.group_user = User.objects.create(username='group_user')
        self.group_user.groups.add(self.group)
        self.group_user.save()

Example 20

Project: django-usertools Source File: tests.py
    def testRemoveSelectedFromGroupAction(self):
        group = Group.objects.create(
            name = "Foo group",
        )
        self.user.groups.add(group)
        self.assertEqual(list(User.objects.get(id=self.user.id).groups.all()), [group])
        response = self.client.post(self.changelist_url, {
            "action": "remove_selected_from_foo_group_{pk}".format(pk=group.pk),
            "_selected_action": self.user.id,
        })
        self.assertEqual(response.status_code, 302)
        self.assertEqual(response["Location"].replace("http://testserver", ""), self.changelist_url)
        self.assertEqual(list(User.objects.get(id=self.user.id).groups.all()), [])

Example 21

Project: django-follow Source File: tests.py
Function: set_up
    def setUp(self):
        
        self.lennon = User.objects.create(username='lennon')
        self.lennon.set_password('test')
        self.lennon.save()
        self.hendrix = User.objects.create(username='hendrix')
        
        self.musicians = Group.objects.create()
        
        self.lennon.groups.add(self.musicians)        

Example 22

Project: rolf Source File: test_views.py
    def setUp(self):
        self.c = Client()
        self.u = UserFactory(is_staff=True)
        self.u.set_password("test")
        self.u.save()
        # need to make the user have at least one group
        g = Group.objects.create(name=self.u.username)
        g.user_set.add(self.u)
        g.save()
        self.c.login(username=self.u.username, password="test")

Example 23

Project: django-sharing Source File: tests.py
Function: set_up
    def setUp(self):
        # Create test object, users, groups, admin object and request.
        self.obj = TestModel.objects.create(id=1)
        self.user = User.objects.create(username='user')
        self.group = Group.objects.create(name='group')
        self.group_user = User.objects.create(username='group_user')
        self.group_user.groups.add(self.group)
        self.group_user.save()
        self.request = RequestFactory().get('/')
        self.share_admin = TestModelAdmin(TestModel, admin.site)

Example 24

Project: django-affect Source File: utils_tests.py
Function: set_up
    def setUp(self):
        self.crit = Criteria.objects.create(name='test_crit')
        self.crit.flags.add(Flag.objects.create(name='test_flag'))
        self.crit.users.add(User.objects.create(username='test_user'))
        self.crit.groups.add(Group.objects.create(name='test_group'))
        self.mock = mox.Mox()
        self.mock.StubOutWithMock(cache, 'add')

Example 25

Project: portal Source File: test_models.py
Function: test_leave_group
    def test_leave_group(self):
        """Test SystersUser leaving an auth Group"""
        group = Group.objects.create(name="Baz")
        self.systers_user.leave_group(group)
        self.systers_user.join_group(group)
        self.assertEqual(self.systers_user.user.groups.get(), group)
        self.systers_user.leave_group(group)
        self.assertSequenceEqual(self.systers_user.user.groups.all(), [])

Example 26

Project: storybase Source File: base.py
    def test_send_create_notification(self):
        backend = getattr(settings, 'EMAIL_BACKEND', None)
        if backend != 'django.core.mail.backends.locmem.EmailBackend':
            self.fail("You must use the in-memory e-mail backend when "
                      "running this test")

        admin_group = Group.objects.create(name=ADMIN_GROUP_NAME)
        admin = User.objects.create(username='admin', 
            password='password', email='[email protected]')
        admin.groups.add(admin_group)
        view = self.view_class()
        obj = self.create_model(name="Test Organization")
        view.send_create_notification(obj)
        from django.core.mail import outbox
        sent_email = outbox[0]
        self.assertIn(admin.email, sent_email.to)
        self.assertIn(obj.name, sent_email.body)

Example 27

Project: django-affect Source File: utils_tests.py
    def test_user_in_cached_groups(self):
        self.request.user = User.objects.create(
            username='test_user')
        group = Group.objects.create(name='test_group')
        self.request.user.groups.add(group)
        self.crit.groups.add(group)
        self.mock.StubOutWithMock(cache, 'get')
        cache.get('criteria:test_crit')
        cache.get('criteria:test_crit:users')
        cache.get('criteria:test_crit:groups').AndReturn([group])
        self.mock.StubOutWithMock(utils, 'cache_criteria')
        utils.cache_criteria(instance=self.crit)  # criteria
        utils.cache_criteria(instance=self.crit)  # users

        self.mock.ReplayAll()
        self.assertIs(
            meets_criteria(self.request, 'test_crit'), True)
        self.mock.VerifyAll()

Example 28

Project: portal Source File: test_models.py
    def test_get_member_groups(self):
        """Test getting groups of which the user is a member"""
        groups = create_groups("Bar")
        self.assertEqual(self.systers_user.get_member_groups(groups), [])
        first_group = groups[0]
        self.systers_user.join_group(first_group)
        self.assertSequenceEqual(self.systers_user.get_member_groups(groups),
                                 [first_group])
        last_group = groups[-1]
        self.systers_user.join_group(last_group)
        self.assertCountEqual(self.systers_user.get_member_groups(groups),
                              [first_group, last_group])
        group = Group.objects.create(name="Dummy")
        self.systers_user.join_group(group)
        self.assertCountEqual(self.systers_user.get_member_groups(groups),
                              [first_group, last_group])

Example 29

Project: django-connections Source File: test_connections.py
    def test_validate_ctypes(self):
        group = Group.objects.create(name='testgroup')
        try:
            self.r._validate_ctypes(self.foo, self.bar)
            self.assertRaises(AssertionError, self.r._validate_ctypes, group, self.bar)
            self.assertRaises(AssertionError, self.r._validate_ctypes, self.bar, group)
        finally:
            group.delete()

Example 30

Project: myks-gallery Source File: test_models.py
Function: set_up
    def setUp(self):
        today = datetime.date.today()
        self.album = Album.objects.create(category='default', dirpath='foo', date=today)
        self.photo = Photo.objects.create(album=self.album, filename='bar')
        self.group = Group.objects.create(name='group')
        self.user = User.objects.create_user('user', 'user@gallery', 'pass')
        self.user.groups.add(self.group)
        self.other = User.objects.create_user('other', 'other@gallery', 'word')

Example 31

Project: django-lfc Source File: permission_tests.py
    def setUp(self):
        """
        """
        Portal.objects.create()
        self.editor = Role.objects.create(name="editor")
        self.user = User.objects.create(username="user", is_active=True)
        self.user.set_password("secret")
        self.user.save()

        self.group = Group.objects.create(name="group")

        self.page_1 = Page.objects.create(title="Page 1", slug="page-1")
        self.page_2 = Page.objects.create(title="Page 2", slug="page-2", parent=self.page_1)
        self.page_3 = Page.objects.create(title="Page 3", slug="page-3", parent=self.page_2)

Example 32

Project: django-hitcount Source File: test_views.py
    @override_settings(HITCOUNT_EXCLUDE_USER_GROUP=('Admin',))
    def test_exclude_user_group(self):
        """
        Exclude user by adding a group setting.
        """
        self.request_post.user = User.objects.create_user('john', '[email protected]', 'johnpassword')
        group = Group.objects.create(name='Admin')
        group.user_set.add(self.request_post.user)

        response = HitCountMixin.hit_count(self.request_post, self.hit_count)
        self.assertFalse(response.hit_counted)
        self.assertEqual(response.hit_message, 'Not counted: user excluded by group')

Example 33

Project: django-cms Source File: test_menu_page_viewperm.py
Function: setup_user
    def _setup_user(self):
        user = self._create_user('user_6', True)
        group = Group.objects.create(name=self.GROUPNAME_6)
        user_set = getattr(group, 'user_set')
        user_set.add(user)
        group.save()

Example 34

Project: pinax-points Source File: tests.py
Function: set_up
    def setUp(self):
        self.setup_users(5)
        self.setup_points({
            "TEST_THIS_TAG": 10,
        })
        group = Group.objects.create(name="Eldarion")
        user = self.users[0]
        # award 40 now and 10 set three weeks ago
        award_points(group, "TEST_THIS_TAG")
        apv = award_points(group, "TEST_THIS_TAG")
        apv.timestamp = apv.timestamp - timedelta(days=14)
        apv.save()
        award_points(user, "TEST_THIS_TAG")
        award_points(user, "TEST_THIS_TAG")
        award_points(user, "TEST_THIS_TAG")
        award_points(user, "TEST_THIS_TAG")
        apv = award_points(user, "TEST_THIS_TAG")
        apv.timestamp = apv.timestamp - timedelta(days=21)
        apv.save()

Example 35

Project: django Source File: test_handlers.py
Function: test_groups_for_user
    def test_groups_for_user(self):
        """
        Check that groups_for_user returns correct values as per
        https://modwsgi.readthedocs.io/en/develop/user-guides/access-control-mechanisms.html#apache-group-authorisation
        """
        user1 = User.objects.create_user('test', '[email protected]', 'test')
        User.objects.create_user('test1', '[email protected]', 'test1')
        group = Group.objects.create(name='test_group')
        user1.groups.add(group)

        # User not in database
        self.assertEqual(groups_for_user({}, 'unknown'), [])

        self.assertEqual(groups_for_user({}, 'test'), [b'test_group'])
        self.assertEqual(groups_for_user({}, 'test1'), [])

Example 36

Project: wagtail Source File: test_admin_views.py
    def test_as_ordinary_editor(self):
        user = get_user_model().objects.create_user(username='editor', email='[email protected]', password='password')

        add_permission = Permission.objects.get(content_type__app_label='wagtailimages', codename='add_image')
        admin_permission = Permission.objects.get(content_type__app_label='wagtailadmin', codename='access_admin')
        image_adders_group = Group.objects.create(name='Image adders')
        image_adders_group.permissions.add(admin_permission)
        GroupCollectionPermission.objects.create(group=image_adders_group, collection=Collection.get_first_root_node(), permission=add_permission)
        user.groups.add(image_adders_group)

        self.client.login(username='editor', password='password')

        response = self.client.get(reverse('wagtailimages:add_multiple'))
        self.assertEqual(response.status_code, 200)
        self.assertTemplateUsed(response, 'wagtailimages/multiple/add.html')

Example 37

Project: django-notifications Source File: tests.py
    def setUp(self):
        self.message_count = 10
        self.from_user = User.objects.create(username="from2", password="pwd", email="[email protected]")
        self.to_user = User.objects.create(username="to2", password="pwd", email="[email protected]")
        self.to_group = Group.objects.create(name="to2_g")
        self.to_group.user_set.add(self.to_user)
        for i in range(self.message_count):
            notify.send(self.from_user, recipient=self.to_user, verb='commented', action_object=self.from_user)
        # Send notification to group
        notify.send(self.from_user, recipient=self.to_group, verb='commented', action_object=self.from_user)
        self.message_count += 1

Example 38

Project: django-auth-ldap-ad Source File: tests.py
    def test_user_groups_001(self):
        """ Test for groups list requirements """
        Group.objects.create(name="MyPonies")
        self._init_settings(
            SEARCH_DN="o=test",
            USER_GROUPS_BY_GROUP={
                'MyPonies': (
                    'cn=superuser,dc=test_not_found',
                    'cn=fake,cn=superuser,ou=foo')})
        self.backend.authenticate(username='alice', password='alicepw')
        user_alice = User.objects.get(username="alice")
        self.assertEqual(user_alice.groups.filter(name="MyPonies").count(), 1)

Example 39

Project: edx-platform Source File: test_manage_group.py
    def set_group_permissions(self, group_permissions):
        """
        Sets up a before-state for groups and permissions in tests, which
        can be checked afterward to ensure that a failed atomic
        operation has not had any side effects.
        """
        content_type = ContentType.objects.get_for_model(Group)
        for group_name, permission_codenames in group_permissions.items():
            group = Group.objects.create(name=group_name)
            for codename in permission_codenames:
                group.permissions.add(
                    Permission.objects.get(content_type=content_type, codename=codename)  # pylint: disable=no-member
                )

Example 40

Project: django-autocomplete-light Source File: test_views.py
Function: setup_class
    @classmethod
    def setUpClass(cls):
        for i in range(0, 3):
            Group.objects.create(name='ViewTestCase%s' % i)

        cls.request = test.RequestFactory().get('?q=foo')
        super(Select2QuerySetSequenceViewTestCase, cls).setUpClass()

Example 41

Project: edx-platform Source File: test_manage_user.py
    def test_nonexistent_group(self):
        """
        Ensures the command does not fail if specified groups cannot be found.
        """
        user = User.objects.create(username=TEST_USERNAME, email=TEST_EMAIL)
        groups = {}
        for group_name in 'abc':
            groups[group_name] = Group.objects.create(name=group_name)
            user.groups.add(groups[group_name])

        call_command('manage_user', TEST_USERNAME, TEST_EMAIL, '-g', 'b', 'c', 'd')
        actual_groups = [group.name for group in user.groups.all()]
        self.assertEqual(actual_groups, ['b', 'c'])

Example 42

Project: pinax-points Source File: tests.py
    def test_unicode_simple_generic_point_award(self):
        self.setup_points({
            "ATE_SOMETHING": 5,
        })
        group = Group.objects.create(name="Dwarfs")
        award_points(group, "ATE_SOMETHING")
        apv = AwardedPointValue.objects.all()[0]
        self.assertEqual(
            str(apv),
            "{0} points for {1} awarded to {2}".format(5, "ATE_SOMETHING", str(group))
        )

Example 43

Project: django-usertools Source File: tests.py
    def testAddSelectedToGroupAction(self):
        group = Group.objects.create(
            name = "Foo group",
        )
        response = self.client.post(self.changelist_url, {
            "action": "add_selected_to_foo_group_{pk}".format(pk=group.pk),
            "_selected_action": self.user.id,
        })
        self.assertEqual(response.status_code, 302)
        self.assertEqual(response["Location"].replace("http://testserver", ""), self.changelist_url)
        self.assertEqual(list(User.objects.get(id=self.user.id).groups.all()), [group])

Example 44

Project: django-pytest Source File: auth_funcargs.py
def pytest_funcarg__groups(request):
    '''Create some groups with users in them.'''
    groups = []
    for i in range(1, 4):
        group = Group.objects.create(name="group%s" % i)
        user = User.objects.create_user(username="group%s" % i,
                password="user",
                email="group%[email protected]" % i)
        group.user_set.add(user)
        group.save()
        groups.append(group)
    return groups

Example 45

Project: amy Source File: base.py
    def _setUpPermissions(self):
        '''Set up permission objects for consistent form selection.'''
        badge_admin = Group.objects.create(name='Badge Admin')
        badge_admin.permissions.add(*Permission.objects.filter(
            codename__endswith='_badge'))
        try:
            add_badge = Permission.objects.get(codename='add_badge')
        except:
            print([p.codename for p in Permission.objects.all()])
            raise
        self.ironman.groups.add(badge_admin)
        self.ironman.user_permissions.add(add_badge)
        self.ron.groups.add(badge_admin)
        self.ron.user_permissions.add(add_badge)
        self.spiderman.groups.add(badge_admin)
        self.spiderman.user_permissions.add(add_badge)

Example 46

Project: pinax-points Source File: tests.py
    def test_simple_generic_point_award(self):
        self.setup_points({
            "ATE_SOMETHING": 5,
        })
        group = Group.objects.create(name="Dwarfs")
        award_points(group, "ATE_SOMETHING")
        self.assertEqual(points_awarded(group), 5)

Example 47

Project: pinax-points Source File: tests.py
    def test_unicode_generic_one_off_point_award(self):
        group = Group.objects.create(name="Dwarfs")
        award_points(group, 500)
        apv = AwardedPointValue.objects.all()[0]
        self.assertEqual(
            str(apv),
            "{0} points awarded to {1}".format(500, str(group))
        )

Example 48

Project: PyClassLessons Source File: test_handlers.py
Function: test_groups_for_user
    @skipIfCustomUser
    def test_groups_for_user(self):
        """
        Check that groups_for_user returns correct values as per
        http://code.google.com/p/modwsgi/wiki/AccessControlMechanisms#Apache_Group_Authorisation
        """
        user1 = User.objects.create_user('test', '[email protected]', 'test')
        User.objects.create_user('test1', '[email protected]', 'test1')
        group = Group.objects.create(name='test_group')
        user1.groups.add(group)

        # User not in database
        self.assertEqual(groups_for_user({}, 'unknown'), [])

        self.assertEqual(groups_for_user({}, 'test'), [b'test_group'])
        self.assertEqual(groups_for_user({}, 'test1'), [])

Example 49

Project: portal Source File: test_models.py
Function: test_is_group_member
    def test_is_group_member(self):
        """Test if SystersUser is a member of a group"""
        group = Group.objects.create(name="Foo")
        self.assertFalse(self.systers_user.is_group_member("Foo"))
        self.systers_user.join_group(group)
        self.assertTrue(self.systers_user.is_group_member("Foo"))

Example 50

Project: storybase Source File: base.py
Function: set_up
    def setUp(self):
        super(PermissionTestCase, self).setUp()
        self.admin_group = Group.objects.create(name=django.conf.settings.ADMIN_GROUP_NAME)
        self.user1 = User.objects.create_user("test1", "[email protected]",
                                              "test1")
        self.user2 = User.objects.create_user("test2", "[email protected]",
                                              "test2")
        self.admin_user = User.objects.create_user(
                'test_admin',
                '[email protected]', 'password')
        self.admin_user.groups.add(self.admin_group)
        self.superuser = User.objects.create_user(
                'test_superuser',
                '[email protected]', 'password')
        self.superuser.is_superuser = True
        self.superuser.save()
        self.anonymous_user = AnonymousUser()
See More Examples - Go to Next Page
Page 1 Selected Page 2 Page 3