def test_copy_exclude_fields(self): """Test the models copy method with excluding fields. When passing an excluded fields list, the value will become None or the models default for that field. """ test_model = TestModel.objects.create( created_user=self.user, some_unique_field=random_alphanum(), some_unique_field_blank=random_alphanum(), some_unique_field_default=random_alphanum()) exclude_fields = [ 'some_string_w_default', 'some_int', 'some_string_no_default', 'some_boolean', 'some_unique_field', 'some_unique_field_blank', 'some_unique_field_default' ] test_model_copy = test_model.copy(exclude_fields=exclude_fields) self.assertEqual(test_model_copy.some_string_w_default, 'hello') self.assertEqual(test_model_copy.some_int, 5) self.assertIsNone(test_model_copy.some_string_no_default) self.assertTrue(test_model_copy.some_boolean) self.assertIsNone(test_model_copy.some_unique_field) self.assertIsNone(test_model_copy.some_unique_field_blank) self.assertEqual(test_model_copy.some_unique_field_default, 'Hello world')
def test_expire_by_emails(self): """Test expiring tokens by an email addresses.""" email_address_1 = 'testing@example1{0}.com'.format(random_alphanum(5)) email_address_2 = 'testing@example2{0}.com'.format(random_alphanum(5)) reason = 'BECAUSE_I_AM_TESTING_{0}'.format(random_alphanum(5)) # created the token auth for email 1 TokenAuthorization.objects.create(email_address=email_address_1, reason=reason, created_user=self.user) # created the token auth for email 2 TokenAuthorization.objects.create(email_address=email_address_2, reason=reason, created_user=self.user) TokenAuthorization.objects.expire_by_emails( email_addresses=[email_address_1, email_address_2], reason=reason) token_auths = TokenAuthorization.objects.filter( email_address__in=[email_address_1, email_address_2]) self.assertEqual(len(token_auths), 2) for auth in token_auths: self.assertTrue(auth.is_expired())
def test_get_by_id(self): """Test getting an object by id.""" test_model = TestModel.objects.create( created_user=self.user, some_unique_field=random_alphanum(), some_unique_field_default=random_alphanum()) test_model_db = TestModel.objects.get_by_id(id=test_model.id) self.assertEqual(test_model, test_model_db)
def test_get_or_none(self): """Getting an object which returns None if one is not found.""" test_model = TestModel.objects.create( created_user=self.user, some_unique_field=random_alphanum(), some_unique_field_default=random_alphanum()) test_model_db = TestModel.objects.get_or_none(id=test_model.id) self.assertEqual(test_model, test_model_db) self.assertIsNone(TestModel.objects.get_or_none(id=1234567890))
def test_forgot_username_form_email_invalid(self): """Test the forgot username user's email""" random_email = '{0}@{1}.com'.format(random_alphanum(5), random_alphanum(5)) form = ForgotUsernameForm(data={'email': random_email}) self.assertFalse(form.is_valid()) form.cleaned_data['email'] = random_email with self.assertRaises(ValidationError): form.clean_email()
def test_forgot_username_form_email_invalid(self): """Test the forgot username user's email""" random_email = '{0}@{1}.com'.format(random_alphanum(5), random_alphanum(5)) form = ForgotUsernameForm(data={'email': random_email}) self.assertFalse(form.is_valid()) form.cleaned_data['email'] = random_email with self.assertRaises(ValidationError): form.clean_email()
def test_umanage_change_email_activation_view(self): """Test the change email activation url to ensure it renders correctly. """ new_email_address = '{0}@{1}.com'.format(random_alphanum(5), random_alphanum(5)) authorization = ChangeEmailAuthorization.objects.create( created_user=self.user, email_address=new_email_address) self.response_test_get(url=authorization.get_absolute_url(), expected_status_code=302) test_user = get_user_model().objects.get(id=self.user.id) self.assertEqual(test_user.email, new_email_address)
def get_available_tokens(self, count=10, token_length=15, **kwargs): """Gets a list of available tokens. :param count: the number of tokens to return. :param token_length: the length of the tokens. The higher the number the easier it will be to return a list. If token_length == 1 there's a strong probability that the enough tokens will exist in the db. """ # This is the number of extra tokens to try and retrieve so calls to # the db can be limited token_buffer = int(math.ceil(count * .05)) if token_buffer < 5: token_buffer = 5 available = set([]) while True: tokens = [ random_alphanum(length=token_length) for t in range(count + token_buffer) ] db_tokens = self.filter(token__in=tokens).values_list('token', flat=True) available.update(set(tokens).difference(db_tokens)) if len(available) >= count: return list(available)[:count]
def test_umanage_change_email_activation_view(self): """Test the change email activation url to ensure it renders correctly. """ new_email_address = '{0}@{1}.com'.format(random_alphanum(5), random_alphanum(5)) authorization = ChangeEmailAuthorization.objects.create( created_user=self.user, email_address=new_email_address ) self.response_test_get( url=authorization.get_absolute_url(), expected_status_code=302 ) test_user = get_user_model().objects.get(id=self.user.id) self.assertEqual(test_user.email, new_email_address)
def test_get_by_slug(self): """Test model manager get by slug.""" slug = slugify(random_alphanum()) obj = TestManagerModel.objects.create(created_user=self.user, slug=slug) obj_db = TestManagerModel.objects.get_by_slug(slug=slug) self.assertEqual(obj, obj_db)
def test_forgot_password_form_user_invalid(self): """Test the forgot password user's email""" form = ForgotPasswordForm(data={'username_or_email': random_alphanum()}) self.assertFalse(form.is_valid()) with self.assertRaises(ValidationError): form.clean_username_or_email()
def test_get_by_token(self): """Test model manager get by token.""" token = random_alphanum() obj = TestManagerModel.objects.create(created_user=self.user, token=token) obj_db = TestManagerModel.objects.get_by_token(token=token) self.assertEqual(obj, obj_db)
def get_available_tokens(self, count=10, token_length=15, **kwargs): """Gets a list of available tokens. :param count: the number of tokens to return. :param token_length: the length of the tokens. The higher the number the easier it will be to return a list. If token_length == 1 there's a strong probability that the enough tokens will exist in the db. """ # This is the number of extra tokens to try and retrieve so calls to # the db can be limited token_buffer = int(math.ceil(count * .05)) if token_buffer < 5: token_buffer = 5 available = set([]) while True: tokens = [random_alphanum(length=token_length) for t in range(count + token_buffer)] db_tokens = self.filter(token__in=tokens).values_list('token', flat=True) available.update(set(tokens).difference(db_tokens)) if len(available) >= count: return list(available)[:count]
def test_forgot_password_form_user_invalid(self): """Test the forgot password user's email""" form = ForgotPasswordForm( data={'username_or_email': random_alphanum()}) self.assertFalse(form.is_valid()) with self.assertRaises(ValidationError): form.clean_username_or_email()
def test_random_utils_lower_only(self): """Test len of random utils for lower only characters.""" random_val = random_alphanum(35, lower_only=True) self.assertEqual(len(random_val), 35) for c in random_val: if not c.isdigit() and not c.islower(): self.fail('Random value has an upper case character: ' '{0}'.format(random_val))
def test_copy1(self): test_model = TestModel.objects.create( created_user=self.user, some_unique_field=random_alphanum(), some_unique_field_blank=random_alphanum(), some_unique_field_default=random_alphanum()) test_model_copy = test_model.copy() utcnow = datetime.utcnow() self.assertIsNone(test_model_copy.id) self.assertTrue(test_model_copy.created_dttm <= utcnow) self.assertTrue(test_model_copy.last_modified_dttm <= utcnow) self.assertEqual(test_model_copy.last_modified_user, test_model_copy.created_user) self.assertIsNone(test_model_copy.some_unique_field) self.assertIsNone(test_model_copy.some_unique_field_blank) self.assertEqual(test_model_copy.some_unique_field_default, 'Hello world')
def create_blog_entries(self, user): entry1 = Entry.objects.create( title='title', slug='title-{0}'.format(random_alphanum()), body='content', created_user=user) entry2 = Entry.objects.create( title=('title kal jdfalkd klsjdals kfjaklfjaskdljfklfjsj fkajsflk' 'sjflkdsjf slkdjflkdj lk'), slug='title-{0}'.format(random_alphanum()), body='content', created_user=user ) entry3 = Entry.objects.create( title='title-3', slug='title-{0}'.format(random_alphanum()), body='content', created_user=user ) print('added 3 new blog entries for: {0}'.format(user.username))
def test_create_blog_posts(self): # - get the user # self.non_superuser() user = create_user(username=random_alphanum()) # - get the number of current blog posts count_before = Entry.objects.filter(created_user=user).count() # - run the management command call_command('datascript', user.username) # - assert that after the manamaement command has run that the user now # has 3 more blog entries than they did before running the management # command. count_after = Entry.objects.filter(created_user=user).count() self.assertEqual(count_after - count_before, 3)
def test_expire_by_email_proxy_model(self): """Test expiring tokens by an email address.""" email_address = 'testing@example{0}.com'.format(random_alphanum(5)) num_tokens = 3 created_tokens = [] for num in range(num_tokens): created_tokens.append( TestTokenAuthorization.objects.create( email_address=email_address, created_user=self.user)) TestTokenAuthorization.objects.expire_by_email( email_address=email_address) token_auths = TestTokenAuthorization.objects.filter( email_address=email_address) self.assertEqual(len(token_auths), num_tokens) for auth in token_auths: self.assertTrue(auth.is_expired())
def test_copy_override_fields(self): """Test overriding fields with the model's .copy method.""" test_model = TestModel.objects.create( created_user=self.user, some_unique_field=random_alphanum(), some_unique_field_blank=random_alphanum(), some_unique_field_default=random_alphanum()) some_string_w_default = random_alphanum() some_int = randint(1, 1000) some_string_no_default = random_alphanum() some_boolean = False some_unique_field = random_alphanum() some_unique_field_blank = random_alphanum() some_unique_field_default = random_alphanum() test_model_copy = test_model.copy( some_string_w_default=some_string_w_default, some_int=some_int, some_string_no_default=some_string_no_default, some_boolean=some_boolean, some_unique_field=some_unique_field, some_unique_field_blank=some_unique_field_blank, some_unique_field_default=some_unique_field_default) self.assertEqual(test_model_copy.some_string_w_default, some_string_w_default) self.assertEqual(test_model_copy.some_int, some_int) self.assertEqual(test_model_copy.some_string_no_default, some_string_no_default) self.assertEqual(test_model_copy.some_boolean, some_boolean) self.assertEqual(test_model_copy.some_unique_field, some_unique_field) self.assertEqual(test_model_copy.some_unique_field_blank, some_unique_field_blank) self.assertEqual(test_model_copy.some_unique_field_default, some_unique_field_default)
def test_expire_by_email_all_reasons(self): """Test expiring tokens by an email address for all reasons.""" email_address = 'testing@example{0}.com'.format(random_alphanum(5)) reason = 'BECAUSE_I_AM_TESTING' num_tokens = 3 created_tokens = [] for num in range(num_tokens): created_tokens.append( TokenAuthorization.objects.create( email_address=email_address, reason='TEST_REASON_{0}'.format(num), created_user=self.user)) TokenAuthorization.objects.expire_by_email(email_address=email_address, reason=None) token_auths = TokenAuthorization.objects.filter( email_address=email_address) self.assertEqual(len(token_auths), num_tokens) for auth in token_auths: self.assertTrue(auth.is_expired())
def test_get_next_slug(self): """Test getting next available slug.""" slug = slugify(random_alphanum()) TestManagerModel.objects.create(created_user=self.user, slug=slug) next_slug = TestManagerModel.objects.get_next_slug(slug=slug) self.assertEqual(next_slug, '{0}-1'.format(slug))
def test_not_is_slug_available(self): """Test if a slug is not available.""" slug = slugify(random_alphanum()) TestManagerModel.objects.create(created_user=self.user, slug=slug) self.assertFalse(TestManagerModel.objects.is_slug_available(slug=slug))
def test_is_slug_available(self): """Test if a slug is available.""" self.assertTrue( TestManagerModel.objects.is_slug_available(slug=random_alphanum()))
def create_user(username=None): """Create a new test user.""" return User.objects.create( username=username or random_alphanum(), email='{0}@blah.com'.format(random_alphanum()) )
def test_len_random_utils_high_length(self): """Test high random utils length.""" self.assertEqual(len(random_alphanum(75)), 75)
def test_len_random_utils(self): """Test len of random utils string.""" self.assertEqual(len(random_alphanum(15)), 15)