django.contrib.auth.models.User.objects.create

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

299 Examples 7

3 Source : test_models.py
with MIT License
from 0soft

    def test_for_user_no_perms(self):
        user = User.objects.create(username="no_perm")
        self.assertEqual(
            set(Issue.objects.for_user(user, ["tests.can_read"])),
            set(),
        )
        self.assertEqual(
            set(Issue.objects.for_user(user, "tests.can_read")),
            set(),
        )

    def test_for_user_global_perm(self):

3 Source : test_models.py
with MIT License
from 0soft

    def test_for_user_global_perm(self):
        user = User.objects.create(username="global_perm")
        ct = ContentType.objects.get_for_model(Issue)
        permission = Permission.objects.get(content_type=ct, codename="can_read")
        user.user_permissions.add(permission)
        self.assertEqual(
            set(Issue.objects.for_user(user, ["tests.can_read"])),
            set(self.issues),
        )
        self.assertEqual(
            set(Issue.objects.for_user(user, "tests.can_read")),
            set(self.issues),
        )

    def test_for_user_superuser(self):

3 Source : test_models.py
with MIT License
from 0soft

    def test_has_perm_no_perm(self):
        user = User.objects.create(username="no_perm")

        for i in self.issues:
            self.assertFalse(i.has_perm(user, ["can_read"]))
            self.assertFalse(i.has_perm(user, "can_read"))

    def test_has_perm_global_perm(self):

3 Source : test_models.py
with MIT License
from 0soft

    def test_has_perm_global_perm(self):
        user = User.objects.create(username="global_perm")
        ct = ContentType.objects.get_for_model(Issue)
        permission = Permission.objects.get(content_type=ct, codename="can_read")
        user.user_permissions.add(permission)

        for i in self.issues:
            self.assertTrue(i.has_perm(user, ["tests.can_read"]))
            self.assertTrue(i.has_perm(user, "tests.can_read"))

    def test_has_perm(self):

3 Source : test_models.py
with MIT License
from 0soft

    def test_for_user_no_perms(self):
        user = User.objects.create(username="no_perm")
        self.assertEqual(
            set(IssueComment.objects.for_user(user, ["tests.can_read"])),
            set(),
        )
        self.assertEqual(
            set(IssueComment.objects.for_user(user, "tests.can_read")),
            set(),
        )

    def test_for_user_global_perm(self):

3 Source : test_models.py
with MIT License
from 0soft

    def test_for_user_global_perm(self):
        user = User.objects.create(username="global_perm")
        ct = ContentType.objects.get_for_model(Issue)
        permission = Permission.objects.get(content_type=ct, codename="can_read")
        user.user_permissions.add(permission)
        self.assertEqual(
            set(IssueComment.objects.for_user(user, ["tests.can_read"])),
            set(self.issues_comments),
        )
        self.assertEqual(
            set(IssueComment.objects.for_user(user, "tests.can_read")),
            set(self.issues_comments),
        )

    def test_for_user_superuser(self):

3 Source : test_models.py
with MIT License
from 0soft

    def test_has_perm_no_perm(self):
        user = User.objects.create(username="no_perm")

        for i in self.issues_comments:
            self.assertFalse(i.has_perm(user, ["tests.can_read"]))
            self.assertFalse(i.has_perm(user, "tests.can_read"))

    def test_has_perm_global_perm(self):

3 Source : test_models.py
with MIT License
from 0soft

    def test_has_perm_global_perm(self):
        user = User.objects.create(username="global_perm")
        ct = ContentType.objects.get_for_model(Issue)
        permission = Permission.objects.get(content_type=ct, codename="can_read")
        user.user_permissions.add(permission)

        for i in self.issues_comments:
            self.assertTrue(i.has_perm(user, ["tests.can_read"]))
            self.assertTrue(i.has_perm(user, "tests.can_read"))

    def test_has_perm(self):

3 Source : base.py
with Apache License 2.0
from alainivars

    def setUp(self):
        self.client = APIClient()
        self.user = \
            User.objects.create(username="my_user", password="my_passwd")

    def tearDown(self):

3 Source : test_project.py
with Apache License 2.0
from alainivars

    def setUp(self):
        """Define the test client and other test variables."""
        # self.path = reverse('rest_login')
        self.username = "my_user"
        self.password = "my_passwd"
        self.user = User.objects.create(
            username=self.username, password=self.password)
        # Initialize client and force it to use authentication
        self.client = APIClient()
        # self.client.force_authenticate(
        #     user=self.user, token=self.user.auth_token)
        # self.url = reverse('user-detail', kwargs={'pk': self.user.pk})
        self.client.credentials(HTTP_AUTHORIZATION=f'Token {self.user.auth_token}')

    def test_access_with_correct_credential(self):

3 Source : test_admin_common_info_mixin.py
with MIT License
from ambient-innovation

    def setUpTestData(cls):
        super().setUpTestData()

        cls.user = User.objects.create(username='my_user')
        cls.request = cls.get_request(cls.user)

        admin.site.register(CommonInfoBasedModel, TestCommonInfoAdminMixinAdmin)

    @classmethod

3 Source : test_admin_common_info_mixin.py
with MIT License
from ambient-innovation

    def test_created_by_is_not_altered_on_update(self):
        model_admin = TestCommonInfoAdminMixinAdmin(model=CommonInfoBasedModel, admin_site=admin.site)

        other_user = User.objects.create(username='other_user')
        with mock.patch.object(CommonInfoBasedModel, 'get_current_user', return_value=other_user):
            obj = CommonInfoBasedModel.objects.create(value=1, created_by=other_user, lastmodified_by=other_user)

        form = CommonInfoBasedModelForm(instance=obj)
        obj = model_admin.save_form(self.request, form, True)

        self.assertEqual(obj.created_by, other_user)
        self.assertEqual(obj.lastmodified_by, self.user)

3 Source : test_admin_create_form_mixin.py
with MIT License
from ambient-innovation

    def setUpTestData(cls):
        super().setUpTestData()

        cls.super_user = User.objects.create(username='super_user', is_superuser=True)

        admin.site.register(ForeignKeyRelatedModel, TestAdminCreateFormMixinAdmin)

    @classmethod

3 Source : test_admin_no_inlines_for_create_mixin.py
with MIT License
from ambient-innovation

    def setUpTestData(cls):
        super().setUpTestData()

        cls.super_user = User.objects.create(username='super_user', is_superuser=True)

        admin.site.register(MySingleSignalModel, TestAdminNoInlinesForCreateMixinAdmin)

    @classmethod

3 Source : test_admin_request_in_form_mixin.py
with MIT License
from ambient-innovation

    def setUpTestData(cls):
        super().setUpTestData()

        cls.super_user = User.objects.create(username='super_user', is_superuser=True)

        admin.site.register(MySingleSignalModel, TestAdminRequestInFormMixinAdmin)

    @classmethod

3 Source : test_deactivatable_change_view_admin_mixin.py
with MIT License
from ambient-innovation

    def setUpTestData(cls):
        super().setUpTestData()

        # Use random model for this meta test
        cls.admin = TestAdmin(admin_site=None, model=User)
        cls.user = User.objects.create(username="test_user", is_superuser=False)
        cls.super_user = User.objects.create(username="super_user", is_superuser=True)

    def setUp(self) -> None:

3 Source : test_fetch_object_mixin.py
with MIT License
from ambient-innovation

    def setUpTestData(cls):
        super().setUpTestData()

        cls.super_user = User.objects.create(username='super_user', is_superuser=True)

        admin.site.register(MySingleSignalModel, TestFetchObjectMixinAdmin)

    @classmethod

3 Source : test_fetch_parent_object_inline_mixin.py
with MIT License
from ambient-innovation

    def setUpTestData(cls):
        super().setUpTestData()

        cls.super_user = User.objects.create(username='super_user', is_superuser=True)

        admin.site.register(MySingleSignalModel, TestFetchParentObjectInlineMixinAdmin)

    @classmethod

3 Source : test_request_provider_mixin.py
with MIT License
from ambient-innovation

    def test_request_user_set(self):
        user = User.objects.create(username='albertus_magnus')
        request = self.get_request(user)
        self.assertEqual(request.user, user)

    def test_request_user_is_none_working(self):

3 Source : test_request_provider_mixin.py
with MIT License
from ambient-innovation

    def test_passed_user_is_regular_user(self):
        user = User.objects.create(username='albertus_magnus')
        request = self.get_request(user)
        self.assertEqual(request.user, user)

    def test_passed_user_is_anonymous_user(self):

3 Source : test_admin_inlines.py
with MIT License
from ambient-innovation

    def setUpTestData(cls):
        super().setUpTestData()

        cls.super_user = User.objects.create(username='super_user', is_superuser=True)

    def test_read_only_tabular_inline_admin_all_fields_readonly(self):

3 Source : test_admin_model_admins_classes.py
with MIT License
from ambient-innovation

    def setUpTestData(cls):
        super().setUpTestData()

        cls.super_user = User.objects.create(username='super_user', is_superuser=True)

        admin.site.register(MySingleSignalModel, TestReadOnlyAdmin)
        admin.site.register(MyMultipleSignalModel, TestEditableOnlyAdmin)

    @classmethod

3 Source : test_admin_view_mixins.py
with MIT License
from ambient-innovation

    def setUpTestData(cls):
        super().setUpTestData()

        cls.view = TestView()

        cls.super_user = User.objects.create(username='super_user', is_superuser=True)
        cls.regular_user = User.objects.create(username='test_user', is_superuser=False)

        # View needs a request since django 3.2
        request = cls.get_request(cls.super_user)
        cls.view.request = request

    def test_admin_view_mixin_has_view_permission_positive_case(self):

3 Source : test_managers.py
with MIT License
from ambient-innovation

    def setUpTestData(cls):
        super().setUpTestData()

        # Create test user
        cls.user = User.objects.create(username='my-username')

        # Create list of objects
        cls.object_list = [
            MySingleSignalModel.objects.create(value=1),
            MySingleSignalModel.objects.create(value=2),
        ]

    def test_visible_for_regular(self):

3 Source : test_queryset_errors.py
with BSD 3-Clause "New" or "Revised" License
from boxed

def test_queryset_get_error_multi():
    User.objects.create(username='aa')
    User.objects.create(username='ab')
    with pytest.raises(User.MultipleObjectsReturned) as e:
        User.objects.get(username__contains='a')

    assert str(e.value) == """get() returned more than one User -- it returned 2!

Query kwargs:

    username__contains: 'a'"""

3 Source : test_utils.py
with MIT License
from dibs-devs

    def setUp(self):
        user1 = User.objects.create(username="user1", password="chatter12345")
        user2 = User.objects.create(username="user2", password="chatter12345")
        user3 = User.objects.create(username="user3", password="chatter12345")

    def test_create_room_with_valid_input(self):

3 Source : tests.py
with BSD 2-Clause "Simplified" License
from django-auth-ldap

    def test_existing_user(self):
        self._init_settings(USER_DN_TEMPLATE="uid=%(user)s,ou=people,o=test")
        User.objects.create(username="alice")
        user_count = User.objects.count()

        user = authenticate(username="alice", password="password")

        # Make sure we only created one user
        self.assertIsNotNone(user)
        self.assertEqual(User.objects.count(), user_count)

    def test_existing_user_insensitive(self):

3 Source : tests.py
with BSD 2-Clause "Simplified" License
from django-auth-ldap

    def test_no_update_existing(self):
        self._init_settings(
            USER_DN_TEMPLATE="uid=%(user)s,ou=people,o=test",
            USER_ATTR_MAP={"first_name": "givenName", "last_name": "sn"},
            ALWAYS_UPDATE_USER=False,
        )
        User.objects.create(username="alice", first_name="Alicia", last_name="Astro")

        alice = authenticate(username="alice", password="password")
        bob = authenticate(username="bob", password="password")

        self.assertEqual(alice.first_name, "Alicia")
        self.assertEqual(alice.last_name, "Astro")
        self.assertEqual(bob.first_name, "Robert")
        self.assertEqual(bob.last_name, "Barker")

    def test_require_group(self):

3 Source : tests.py
with BSD 2-Clause "Simplified" License
from django-auth-ldap

    def test_group_permissions_ldap_error(self):
        self._init_settings(
            BIND_DN="uid=bob,ou=people,o=test",
            BIND_PASSWORD="bogus",
            USER_DN_TEMPLATE="uid=%(user)s,ou=people,o=test",
            GROUP_SEARCH=LDAPSearch("ou=groups,o=test", ldap.SCOPE_SUBTREE),
            GROUP_TYPE=MemberDNGroupType(member_attr="member"),
            FIND_GROUP_PERMS=True,
        )
        self._init_groups()

        backend = get_backend()
        alice = User.objects.create(username="alice")
        alice = backend.get_user(alice.pk)

        self.assertEqual(backend.get_group_permissions(alice), set())

    def test_empty_group_permissions(self):

3 Source : tests.py
with BSD 2-Clause "Simplified" License
from django-auth-ldap

    def test_empty_group_permissions(self):
        self._init_settings(
            USER_DN_TEMPLATE="uid=%(user)s,ou=people,o=test",
            GROUP_SEARCH=LDAPSearch("ou=groups,o=test", ldap.SCOPE_SUBTREE),
            GROUP_TYPE=MemberDNGroupType(member_attr="member"),
            FIND_GROUP_PERMS=True,
        )
        self._init_groups()

        backend = get_backend()
        bob = User.objects.create(username="bob")
        bob = backend.get_user(bob.pk)

        self.assertEqual(backend.get_group_permissions(bob), set())
        self.assertEqual(backend.get_all_permissions(bob), set())
        self.assertIs(backend.has_perm(bob, "auth.add_user"), False)
        self.assertIs(backend.has_module_perms(bob, "auth"), False)

    def test_posix_group_permissions(self):

3 Source : tests.py
with BSD 2-Clause "Simplified" License
from django-auth-ldap

    def test_foreign_user_permissions(self):
        self._init_settings(
            USER_DN_TEMPLATE="uid=%(user)s,ou=people,o=test",
            GROUP_SEARCH=LDAPSearch("ou=groups,o=test", ldap.SCOPE_SUBTREE),
            GROUP_TYPE=MemberDNGroupType(member_attr="member"),
            FIND_GROUP_PERMS=True,
        )
        self._init_groups()

        backend = get_backend()
        alice = User.objects.create(username="alice")

        self.assertEqual(backend.get_group_permissions(alice), set())

    @spy_ldap("search_s")

3 Source : tests.py
with BSD 2-Clause "Simplified" License
from django-auth-ldap

    def test_authorize_external_users(self):
        self._init_settings(
            USER_DN_TEMPLATE="uid=%(user)s,ou=people,o=test",
            GROUP_SEARCH=LDAPSearch("ou=groups,o=test", ldap.SCOPE_SUBTREE),
            GROUP_TYPE=MemberDNGroupType(member_attr="member"),
            FIND_GROUP_PERMS=True,
            AUTHORIZE_ALL_USERS=True,
        )
        self._init_groups()

        backend = get_backend()
        alice = User.objects.create(username="alice")

        self.assertEqual(
            backend.get_group_permissions(alice), {"auth.add_user", "auth.change_user"}
        )

    def test_authorize_external_unknown(self):

3 Source : tests.py
with BSD 2-Clause "Simplified" License
from django-auth-ldap

    def test_authorize_external_unknown(self):
        self._init_settings(
            USER_SEARCH=LDAPSearch(
                "ou=people,o=test", ldap.SCOPE_SUBTREE, "(uid=%(user)s)"
            ),
            GROUP_SEARCH=LDAPSearch("ou=groups,o=test", ldap.SCOPE_SUBTREE),
            GROUP_TYPE=MemberDNGroupType(member_attr="member"),
            FIND_GROUP_PERMS=True,
            AUTHORIZE_ALL_USERS=True,
        )
        self._init_groups()

        backend = get_backend()
        alice = User.objects.create(username="not-in-ldap")

        self.assertEqual(backend.get_group_permissions(alice), set())

    def test_create_without_auth(self):

3 Source : test_views.py
with GNU General Public License v3.0
from esrg-knights

    def test_authenticated_user(self):
        self.client.force_login(User.objects.create())

        response = self.assertValidGetResponse()
        self.assertTemplateUsed(response, HomeUsersView.template_name)
        self.assertIn('activities', response.context)

    def test_home_page_message(self):

3 Source : test_views.py
with GNU General Public License v3.0
from esrg-knights

    def test_home_page_message(self):
        # Set environment variables
        global_preferences['homepage__home_page_message'] = "Here is a message"

        self.client.force_login(User.objects.create())
        msg = self.assertValidGetResponse().context['unique_messages'][0]

        self.assertIn('msg_text', msg)
        self.assertEqual(msg['msg_type'], "info")

    def test_home_page_extend_membership_message(self):

3 Source : test_views.py
with GNU General Public License v3.0
from esrg-knights

    def test_home_page_extend_membership_message(self):
        # Set environment variables
        global_preferences['membership__signup_year'] = MemberYear.objects.create(name='current year')

        self.client.force_login(User.objects.create())
        msg = self.assertValidGetResponse().context['unique_messages'][0]

        self.assertIn('msg_text', msg)
        self.assertIn('btn_text', msg)
        self.assertEqual(msg['msg_type'], "info")
        self.assertEqual(msg['btn_url'],  reverse('membership_file/continue_membership'))

3 Source : test_testing_views.py
with GNU General Public License v3.0
from esrg-knights

    def setUp(self):
        user = User.objects.create()
        self.base_user_id = user.id
        super(TestViewValidityMixin, self).setUp()

    def test_setup(self):

3 Source : test_remoteapp.py
with GNU Affero General Public License v3.0
from f-droid

    def test_add_to_repo_without_apks(self):
        # create pre-requisites
        repo = Repository.objects.create(name='test', user=User.objects.create(username='user2'))

        # try to add remote app without any APKs to local repo
        with self.assertRaises(ValidationError):
            self.app.add_to_repo(repo)

3 Source : test_screenshot.py
with GNU Affero General Public License v3.0
from f-droid

    def setUp(self):
        # remote objects
        self.remote_repo = RemoteRepository.objects.get(pk=1)
        date = datetime.fromtimestamp(1337, timezone.utc)
        self.remote_app = RemoteApp.objects.create(repo=self.remote_repo, name='TestApp',
                                                   package_id='org.example', last_updated_date=date)
        self.remote_screenshot = RemoteScreenshot.objects.create(app=self.remote_app,
                                                                 url='test_url/test.png')

        # local objects
        self.user = User.objects.create(username='user2')
        self.repo = Repository.objects.create(user=self.user)
        self.app = App.objects.create(repo=self.repo, package_id='org.example')

    def tearDown(self):

3 Source : test_storage.py
with GNU Affero General Public License v3.0
from f-droid

    def setUp(self):
        # create repo and three remote storage locations
        self.repo = Repository.objects.create(user=User.objects.create(username='user2'),
                                              fingerprint='fake_fingerprint')
        S3Storage.objects.create(repo=self.repo, bucket='s3_bucket')
        SshStorage.objects.create(repo=self.repo, url='ssh_url', disabled=False)
        GitStorage.objects.create(repo=self.repo, url='git_url')

    def test_storage_models_exist(self):

3 Source : test_tasks.py
with GNU Affero General Public License v3.0
from f-droid

    def test_update_repo(self, update, publish):
        # create an actual repository
        repo = Repository.objects.create(user=User.objects.create())

        tasks.update_repo.now(repo.id)  # this repo actually exists

        # assert that repository was updated and published
        update.assert_called_once_with()
        publish.assert_called_once_with()

        # assert that repository is in correct state
        self.assertFalse(repo.update_scheduled)
        self.assertFalse(repo.is_updating)

    @patch('repomaker.models.repository.Repository.publish')

3 Source : test_tasks.py
with GNU Affero General Public License v3.0
from f-droid

    def test_update_repo_already_running(self, update, publish):
        # create an actual repository
        repo = Repository.objects.create(user=User.objects.create(), is_updating=True)

        tasks.update_repo.now(repo.id)  # this repo actually exists, but is updating already

        # assert that nothing was updated and published
        self.assertFalse(update.called)
        self.assertFalse(publish.called)

    @patch('repomaker.models.remoterepository.RemoteRepository.update_index')

3 Source : test_tasks.py
with GNU Affero General Public License v3.0
from f-droid

    def test_download_remote_graphic_assets(self, download_graphic_assets_from_remote_app):
        repo = Repository.objects.create(user=User.objects.create())
        app = App.objects.create(repo=repo)
        date = datetime.fromtimestamp(0, timezone.utc)
        remote_repo = RemoteRepository.objects.create(last_change_date=date)
        remote_app = RemoteApp.objects.create(repo=remote_repo, last_updated_date=date)

        tasks.download_remote_graphic_assets.now(app.id, remote_app.id)

        # assert that APK was downloaded
        download_graphic_assets_from_remote_app.assert_called_once_with(remote_app)

    @patch('repomaker.models.app.App.download_graphic_assets_from_remote_app')

3 Source : test_tasks.py
with GNU Affero General Public License v3.0
from f-droid

    def test_download_remote_graphic_assets_no_remote_app(self,
                                                          download_graphic_assets_from_remote_app):
        repo = Repository.objects.create(user=User.objects.create())
        app = App.objects.create(repo=repo)

        tasks.download_remote_graphic_assets.now(app.id, 1337)

        # assert that downloaded was not scheduled
        self.assertFalse(download_graphic_assets_from_remote_app.called)

    @patch('repomaker.models.screenshot.RemoteScreenshot.download')

3 Source : test_tasks.py
with GNU Affero General Public License v3.0
from f-droid

    def test_priorities(self):
        # create an actual repository and an APK
        repo = Repository.objects.create(user=User.objects.create())
        apk = Apk.objects.create()

        # schedule repo update first and then APK download
        repo.update_async()
        apk.download_async('url')
        # TODO add other types of background tasks here

        # assert that APK download task comes first with a higher priority
        available_tasks = Task.objects.find_available()
        self.assertEqual(2, available_tasks.count())
        self.assertEqual('repomaker.tasks.download_apk', available_tasks[0].task_name)
        self.assertEqual('repomaker.tasks.update_repo', available_tasks[1].task_name)
        self.assertTrue(available_tasks[0].priority > available_tasks[1].priority)

3 Source : test_repository.py
with GNU Affero General Public License v3.0
from f-droid

    def setUp(self):
        super().setUp()

        # create second user
        self.user = User.objects.create(username='user2')

        # create app in repo
        self.app = App.objects.create(repo=self.repo,
                                      package_id='org.bitbucket.tickytacky.mirrormirror',
                                      name='TestApp', website='TestSite', author_name='author')
        self.app.translate(settings.LANGUAGE_CODE)
        self.app.summary = 'TestSummary'
        self.app.description = 'TestDesc'
        self.app.save()

    def test_empty_state(self):

3 Source : __init__.py
with GNU Affero General Public License v3.0
from f-droid

    def setUp(self):
        if not settings.SINGLE_USER_MODE:
            self.user = User.objects.create(username=DEFAULT_USER_NAME)
            self.client.force_login(user=self.user)
        else:
            self.user = User.objects.get()

        self.repo = Repository.objects.create(
            name="Test Name",
            description="Test Description",
            url="https://example.org",
            fingerprint="foongerprint",
            user=self.user,
        )
        self.repo.chdir()

    def tearDown(self):

3 Source : tests.py
with MIT License
from fga-eps-mds

def create_user(client):
    user = User.objects.create(username='username',
                               email='email', is_staff=True)
    user.set_password('password')
    user.save()
    client.login(username='username', password='password')
    return user


@pytest.fixture

3 Source : tests.py
with MIT License
from fga-eps-mds

def create_super_user(client):
    user = User.objects.create(username='username',
                               email='email', is_superuser=True)
    user.set_password('password')
    user.save()
    client.login(username='username', password='password')
    return user


@pytest.fixture

3 Source : tests.py
with MIT License
from fga-eps-mds

def test_delete_tag_detail_return_401(client):
    user = User.objects.create(username='username',
                               email='email')
    user.set_password('password')
    user.save()
    client.login(username='username', password='password')
    tag = mommy.make('Tag')
    url = reverse('tags:tag-detail', kwargs={'pk': tag.id})
    response = client.delete(url, content_type='application/json')

    assert response.status_code == 401

See More Examples