def test_project_comment_events(self): """ Project comment event responses """ self._sign_in(self.user) project = milkman.deliver(Project) project.set_owner(self.admin) root_comment = ProjectComment.add_root(project=project, user=self.admin, text="foo") event = milkman.deliver(Event, timestamp=self.now, kind=EventKind.PROJECTROOTCOMMENTCREATED, object_id=root_comment.pk, project_id=project.pk) request = EventRequestContainer.combined_message_class(ts=self.ts) with self.assertNumQueries(3): response = self.api.event_list(request) self.assertEqual(len(response.events), 1) self.assertEqual(len(response.project_comments), 1) self.assertEqual(response.events[0].id, event.pk) self.assertEqual(response.project_comments[0].id, root_comment.pk)
def create_test_users(self): """ Creates test users """ User = get_user_model() self.admin = milkman.deliver(User, email="*****@*****.**", is_superuser=True, first_name="Polar", last_name="Bear", is_whitelisted=True) self.admin2 = milkman.deliver(User, email="*****@*****.**", is_staff=True, first_name="Manx", last_name="Shearwater", is_whitelisted=True) self.user = milkman.deliver(User, email="*****@*****.**", first_name="Razor", last_name="Bill") self.user2 = milkman.deliver(User, email="*****@*****.**", first_name="Storm", last_name="Petrel")
def test_filter_users(self): """ Test that the correct users are returned when doing partial filters on the first_name, last_name and email fields """ User = get_user_model() # Users with some overlapping details charlie_brown = milkman.deliver(User, first_name="Charlie", last_name="Brown", email="*****@*****.**") charlie_brooker = milkman.deliver(User, first_name="Charlie", last_name="Brooker", email="*****@*****.**") someone_brooker = milkman.deliver(User, first_name="Someone", last_name="Brooker", email="*****@*****.**") def _check_filtered_users(q, *users): self._sign_in(self.admin) response = self.api.users_filter( UserFilterContainer.combined_message_class(q=q)) self.assertIsInstance(response, UserListResponse) items_pks = [item.id for item in response.items] self.assertEqual(len(users), len(items_pks)) for user in users: self.assertTrue(user.pk in items_pks) # Filter on 'example.com' first, it should return all 5 users with self.assertNumQueries(2): _check_filtered_users('example', charlie_brown, charlie_brooker, someone_brooker, self.user, self.user2) # Test some more restrictive filters with self.assertNumQueries(2): _check_filtered_users('charlie', charlie_brown, charlie_brooker) # partial matches work as well with self.assertNumQueries(2): _check_filtered_users('charl', charlie_brown, charlie_brooker) with self.assertNumQueries(2): _check_filtered_users('brooker', charlie_brooker, someone_brooker) with self.assertNumQueries(2): _check_filtered_users('someone', someone_brooker) with self.assertNumQueries(3): _check_filtered_users('Charlie Brooker', charlie_brooker) with self.assertNumQueries(3): _check_filtered_users('Charlie Brown', charlie_brown) # no results with self.assertNumQueries(3): _check_filtered_users('Someone Brown') # no search term and not admin user - should raise forbidden. self._sign_out() self._sign_in(self.user) self.assertRaises(ForbiddenException, self.api.users_filter, UserFilterContainer.combined_message_class(q=None))
def setUp(self): """ Bootstrap data """ super(ProjectChannelAPITests, self).setUp() self.pending_user = milkman.deliver(PendingUser, email="*****@*****.**") self.project = milkman.deliver(Project) self.project.set_owner(self.admin) self.video_1 = self.create_video(channel_id="123", channel_name="foo", project=self.project) self.video_2 = self.create_video(channel_id="123", channel_name="fez", project=self.project) self.video_3 = self.create_video(channel_id="456", channel_name="bar", project=self.project) self.other_video = self.create_video(channel_id="999", channel_name="buzz")
def setUp(self): """ Bootstrap test data """ super(AutoCompleteTagDocumentTestCase, self).setUp() self.user = milkman.deliver(get_user_model(), email="*****@*****.**", first_name='Robbo', last_name='Cop') self.project = milkman.deliver(Project) self.project_2 = milkman.deliver(Project, privacy_tags=1) self.project_3 = milkman.deliver(Project) self.tag, _ = self.create_project_tag( name="RobboCop", description='description 1', image_url='http://robbocop.com/foobar.jpg', project=self.project, user=self.user) self.tag_2, _ = self.create_project_tag( name="RobboCop Private", description='description 1 private', image_url='http://private.robbocop.com/foobar.jpg', project=self.project_2, user=self.user) self.create_project_tag(global_tag=self.tag, project=self.project_3)
def setUp(self): """ Bootstrap with project data """ super(ProjectAPITests, self).setUp() self.pending_user = milkman.deliver(PendingUser, email="*****@*****.**") self.project = milkman.deliver(Project) self.project.set_owner(self.admin) self.project.add_admin(self.user, pending=False) self.project.add_assigned(self.user2, pending=False) self.project.add_assigned(self.pending_user, pending=True) self.favourited_video = self.create_video(project=self.project, favourited=True) self.tagged_video = self.create_video(project=self.project) self.archived_video = self.create_video(project=self.project) self.archived_video.archive() self.deleted_video = self.create_video(project=self.project) self.deleted_video.delete() self.tag, _, video_tag, _ = self.create_video_instance_tag( name='Foo', project=self.project, video=self.tagged_video) self.create_video_instance_tag(video_tag=video_tag, start_seconds=0, end_seconds=42) self.tag2, _, _, _ = self.create_video_instance_tag( name='Bar', project=self.project, video=self.tagged_video)
def setUp(self): """ Bootstrap test data """ super(ProjectCommentAPIListTestCase, self).setUp() self.project = milkman.deliver(Project) self.project.set_owner(self.admin) self.project.add_assigned(self.user, pending=False) self.project_2 = milkman.deliver(Project) # create root comments self.root_comments = [ ProjectComment.add_root(project=self.project, user=self.user, text="foo{0}".format(i), created=datetime.datetime( 2014, 1, 1, i, i, i)) for i in range(1, 6) ] self.other_comments = [ ProjectComment.add_root(project=self.project_2, user=self.user, text="bar{0}".format(i)) for i in range(0, 5) ]
def setUp(self): """ Bootstrap test data """ super(VideoCollectionFilterAPITests, self).setUp() self.project = milkman.deliver(Project) self.project.set_owner(self.admin) self.video_1 = self.create_video( project=self.project, channel_id=u"UCDASmtEzVZS5PZxjiRjcHKA", publish_date=datetime.datetime(2014, 1, 1, tzinfo=timezone.utc), name=u"Bazooka") self.video_2 = self.create_video( channel_id=u"UCmA0uNMDy4wx9NHu1OfAw9g", publish_date=datetime.datetime(2014, 2, 1, tzinfo=timezone.utc), project=self.project, name=u"Bazooka 2") self.collection_1 = milkman.deliver(VideoCollection, project=self.project, name='Collection 1') self.collection_1.add_video(self.video_2) self.collection_1.add_video(self.video_1) self.other_video = self.create_video( youtube_video=self.video_1.youtube_video)
def test_video_events(self): """ Video events responses """ self._sign_in(self.user) video = self.create_video() created_event = milkman.deliver(Event, timestamp=self.now, kind=EventKind.VIDEOCREATED, object_id=video.pk) updated_event = milkman.deliver(Event, timestamp=self.now, kind=EventKind.VIDEOUPDATED, object_id=video.pk) video2 = self.create_video() created_event2 = milkman.deliver(Event, timestamp=self.now, kind=EventKind.VIDEOCREATED, object_id=video2.pk) request = EventRequestContainer.combined_message_class(ts=self.ts) with self.assertNumQueries(3): response = self.api.event_list(request) self.assertEqual(len(response.events), 3) self.assertEqual(len(response.videos), 2) self.assertEqual(response.events[0].id, created_event2.pk) self.assertEqual(response.videos[0].id, video.pk)
def setUp(self): """ Bootstrap test data """ super(ExportVideoTestCase, self).setUp() self.admin = milkman.deliver( get_user_model(), email="*****@*****.**", is_superuser=True, username='******') self.project = milkman.deliver(Project) self.video = self.create_video( project=self.project, name='test video', notes='foobar\nbuzz', latitude='3.14', longitude='5.33') self.tag1, _, _, _ = self.create_video_instance_tag( project=self.project, video=self.video, name='غرفة عمليات انصار') self.comment = TimedVideoComment.add_root( video=self.video, user=self.admin, text='Hello world with UTF chars! غرفة عمليات انصار الشريع', start_seconds=0, ) self.comment_reply = self.comment.add_reply('Goodbye!', self.admin)
def setUp(self): self.page = milkman.deliver(WebPage, slug='test-page', title="page", template='pages/default.html') self.page2 = milkman.deliver(WebPage, slug='test-page-2', title="page2", template='pages/default.html') self.page_resource = PageResource() self.user = User.objects.create_user(username='******', email='*****@*****.**', password='******') self.client.login(username='******', password='******') self.rf = RequestFactory()
def setUp(self): """ Bootstrap test data """ super(UserModelTestCase, self).setUp() self.user = milkman.deliver(User, email="*****@*****.**") self.admin = milkman.deliver( User, email="*****@*****.**", is_superuser=True, is_googler=True)
def test_my_projects(self): """ Get list of projects assigned to a user or they have been invited to """ project2 = milkman.deliver(Project, created=timezone.now() - datetime.timedelta(hours=1)) project2.set_owner(self.admin) project2.add_admin(self.user, pending=False) project3 = milkman.deliver(Project, created=timezone.now() - datetime.timedelta(hours=2)) project3.set_owner(self.user) project4 = milkman.deliver(Project, created=timezone.now() - datetime.timedelta(hours=3)) project4.set_owner(self.admin) project4.add_assigned(self.user) self._sign_in(self.user) with self.assertNumQueries(4): response = self.api.project_list_user( ProjectListRequest.combined_message_class()) self.assertEqual(4, len(response.items)) assigned_project_resp = response.items[0] self.assertEqual(self.project.pk, assigned_project_resp.id) self.assertTrue(assigned_project_resp.current_user_info.is_assigned) self.assertFalse(assigned_project_resp.current_user_info.is_owner) self.assertTrue(assigned_project_resp.current_user_info.is_admin) self.assertFalse(assigned_project_resp.current_user_info.is_pending) self.assertEqual(2, assigned_project_resp.video_count) self.assertEqual(response.items[0].video_tag_instance_count, 3) admin_project_resp = response.items[1] self.assertEqual(project2.pk, admin_project_resp.id) self.assertTrue(admin_project_resp.current_user_info.is_assigned) self.assertFalse(admin_project_resp.current_user_info.is_owner) self.assertTrue(admin_project_resp.current_user_info.is_admin) self.assertFalse(admin_project_resp.current_user_info.is_pending) owner_project_resp = response.items[2] self.assertEqual(project3.pk, owner_project_resp.id) self.assertTrue(owner_project_resp.current_user_info.is_assigned) self.assertTrue(owner_project_resp.current_user_info.is_owner) self.assertTrue(owner_project_resp.current_user_info.is_admin) self.assertFalse(owner_project_resp.current_user_info.is_pending) pending_project_resp = response.items[3] self.assertEqual(project4.pk, pending_project_resp.id) self.assertTrue(pending_project_resp.current_user_info.is_assigned) self.assertFalse(pending_project_resp.current_user_info.is_owner) self.assertFalse(pending_project_resp.current_user_info.is_admin) self.assertTrue(pending_project_resp.current_user_info.is_pending)
def setUp(self): """ Bootstrap test data """ super(VideoModelTestCase, self).setUp() self.project_owner = milkman.deliver(User, email="*****@*****.**") self.project = milkman.deliver(Project) self.project.set_owner(self.project_owner) self.video = self.create_video(project=self.project)
def setUp(self): """ Bootstrap test data """ super(VideoCollectionVideoSignalsTestCase, self).setUp() self.project = milkman.deliver(Project) self.video = self.create_video() self.collection = milkman.deliver( VideoCollection, project=self.project)
def test_save_project_tag_search_document( self, mock_index_global_tag_document): """ Project tag created """ tag = milkman.deliver(GlobalTag) mock_index_global_tag_document.reset_mock() ProjectTag.add_root(project=milkman.deliver(Project), global_tag=tag) mock_index_global_tag_document.assert_called_once_with(tag.pk)
def setUp(self): """ Bootstrap test data """ super(PublishEventHandlerViewTestCase, self).setUp() self.project = milkman.deliver(Project) User = get_user_model() self.user = milkman.deliver(User, email="*****@*****.**")
def setUp(self): """ Bootstrap test data """ super(ProjectCommentTestCase, self).setUp() self.project = milkman.deliver(Project) self.user1 = milkman.deliver(User, email="*****@*****.**") self.user2 = milkman.deliver(User, email="*****@*****.**")
def setUp(self): """ Bootstrap test data """ super(CleanChannelsTestCase, self).setUp() User = get_user_model() self.user = milkman.deliver(User, email="*****@*****.**") self.project = milkman.deliver(Project) self.video = self.create_video(project=self.project)
def test_related_explicit_values(self): child = milkman.deliver(Child, root__my_char='foo') self.assertEqual(child.root.my_char, 'foo') grandchild = milkman.deliver(GrandChild, parent__name='foo', parent__root__my_char='bar') self.assertEqual(grandchild.parent.name, 'foo') self.assertEqual(grandchild.parent.root.my_char, 'bar') root = milkman.deliver(Root) grandchild = milkman.deliver(GrandChild, parent__root=root) self.assertEqual(root.pk, grandchild.parent.root.pk)
def test_has_correct_objects(self): "has correct objects for user (those which can be modified)" yes = milkman.deliver(Trip, where="Yesland", user=self.user) no = milkman.deliver(Trip, where="Nopeland", user=self.user) yes.fully_authorize(self.user) resp = self.client.get(reverse("trips:list")) self.assertIn(yes, resp.context["trip_list"]) self.assertNotIn(no, resp.context["trip_list"])
def create_global_tag(self, project=None, **kwargs): """ Creates a global tag """ if not project: # GlobalTags must be created from a project - create one to # tie it to project = milkman.deliver(Project) return milkman.deliver( GlobalTag, created_from_project=project, **kwargs)
def setUp(self): """ Bootstrap test data """ super(TimedVideoCommentTestCase, self).setUp() self.project = milkman.deliver(Project) self.video = self.create_video(project=self.project) self.user1 = milkman.deliver(User, email="*****@*****.**") self.user2 = milkman.deliver(User, email="*****@*****.**")
def setUp(self): """ Bootstrap data """ super(TagAPITestCase, self).setUp() self.tag1 = milkman.deliver(GlobalTag, name='Han Solo') self.tag2 = milkman.deliver( GlobalTag, name='Chewbacca', description='Han shot first') self.tag3 = milkman.deliver(GlobalTag, name='Luke Skywalker') self.tag4 = milkman.deliver( GlobalTag, name='Leia', description='Kenobi helps Luke')
def create_test_users(self): """ Override creation of test users """ User = get_user_model() # override self.admin = milkman.deliver(User, email="*****@*****.**", is_superuser=True) self.user = milkman.deliver(User, email="*****@*****.**") self.user2 = milkman.deliver(User, email="*****@*****.**")
def setUp(self): """ Bootstrap test data """ super(UserDeletionTestCase, self).setUp() User = get_user_model() # override self.admin = milkman.deliver(User, email="*****@*****.**", is_superuser=True) self.user = milkman.deliver(User, email="*****@*****.**")
def test_force_random(self): root1 = milkman.deliver('tests.root') self.assertFalse(root1.my_string) root2 = milkman.deliver('tests.root', my_string=milkman.random) self.assertTrue(root2.my_string) sibling = milkman.deliver('tests.sibling') self.assertFalse(sibling.root) sibling = milkman.deliver('tests.sibling', root=milkman.random) self.assertTrue(sibling.root in [root1, root2])
def check_assigns_permissions(perm): user = milkman.deliver(User) trip = milkman.deliver(Trip) trip.fully_authorize(user) perm = 'trips.%s_trip' % perm try: assert user.has_perm(perm, trip), \ 'user has no perm %s' % perm finally: user.delete() trip.delete()
def check_assigns_permissions(perm): user = milkman.deliver(User) ba = milkman.deliver(BalancedAccount) ba.fully_authorize(user) perm = 'funding.%s_balancedaccount' % perm try: assert user.has_perm(perm, ba), \ 'user has no perm %s' % perm finally: user.delete() ba.delete()
def check_for_user(kind, perm): user = milkman.deliver(User) ba = milkman.deliver( BalancedAccount, kind=kind, name=':'.join([kind, perm]) ) ba.fully_authorize(user) qs = BalancedAccount.objects.for_user(kind, perm, user) try: assert ba in qs, '%r not in %r' % (ba, qs) finally: user.delete() ba.delete()
def setUp(self): """ Bootstrap test data """ super(ProjectModelTestCase, self).setUp() self.user = milkman.deliver(User, email="*****@*****.**") self.admin = milkman.deliver( User, email="*****@*****.**", is_superuser=True, is_googler=True) self.project_owner = milkman.deliver(User, email="*****@*****.**") self.project = milkman.deliver(Project) self.project.set_owner(self.project_owner) self.project.add_admin(self.admin, pending=False) self.project.add_assigned(self.user, pending=False)
def check_for_user(perm): user = milkman.deliver(User) trip = milkman.deliver( Trip, name=perm ) trip.fully_authorize(user) qs = Trip.objects.for_user(perm, user) try: assert trip in qs, '%r not in %r' % (trip, qs) finally: user.delete() trip.delete()
def setUp(self): """ Bootstrap test data """ super(VideoTagTestCase, self).setUp() self.project = milkman.deliver(Project) self.video = self.create_video(project=self.project) self.globaltag = milkman.deliver(GlobalTag) self.projecttag = ProjectTag.add_root(project=self.project, global_tag=self.globaltag) self.videotag = VideoTag.objects.create(project=self.project, project_tag=self.projecttag, video=self.video)
def setUp(self): """ Bootstrap test data """ super(GlobalTagTestCase, self).setUp() self.private_tag_project_1 = milkman.deliver( Project, privacy_tags=Project.PRIVATE) self.private_tag_project_2 = milkman.deliver( Project, privacy_tags=Project.PRIVATE) self.public_tag_project_1 = milkman.deliver( Project, privacy_tags=Project.PUBLIC) self.public_tag_project_2 = milkman.deliver( Project, privacy_tags=Project.PUBLIC)
def test_empty_search(self): """ Search public tags with no query term """ # create some extra tags to go over the page limit for i in range(1, 10): milkman.deliver(GlobalTag, name="tag{0}".format(i)) self._sign_in(self.user) response = self.api.search_tags( TagSearchEntityContainer.combined_message_class()) self.assertEqual(0, len(response.project_tags)) self.assertEqual(10, len(response.global_tags))
def test_required_field(self): root = milkman.deliver(Root) assert isinstance(root.my_auto, int) try: assert isinstance( root.my_biginteger, type(models.BigIntegerField.MAX_BIGINT)) except AttributeError: pass assert isinstance(root.my_boolean, bool) assert isinstance(root.my_char, str) assert isinstance(root.my_commaseperatedinteger, str) assert isinstance(root.my_date, str) assert isinstance(root.my_datetime, str) assert isinstance(root.my_decimal, str) assert isinstance(root.my_email, str) assert isinstance(root.my_float, float) assert isinstance(root.my_integer, int) assert isinstance(root.my_ip, str) assert (isinstance(root.my_nullboolean, bool) or isinstance(root.my_nullboolean, types.NoneType)) assert isinstance(root.my_positiveinteger, int) assert isinstance(root.my_positivesmallinteger, int) assert isinstance(root.my_slug, str) assert isinstance(root.my_smallinteger, int) assert isinstance(root.my_text, str) assert isinstance(root.my_time, str)
def handle(self, *args, **options): amount = int(args[0]) for i in range(amount): start_date = random_date( datetime.now()+timedelta(days=1), datetime.now()+timedelta(days=30)) end_date = random_date( start_date, start_date+timedelta(days=30) ) users = [] for j in range(random.randint(2, 4)): user = User.objects.order_by('?')[0] if user not in users: users.append(user) try: country = Country.objects.order_by('?')[0] except IndexError: country = Country.objects.get_or_create_normalized( name=random.choice(countries)) trip = milkman.deliver('trip.trip', start_date=start_date, end_date=end_date, country=country, city=random.choice(cities), title=u"Поездка_{0}".format(i), people=users, owner=User.objects.all()[0] ) self.stdout.write("Created trip '{0}'".format(trip)) self.stdout.write("Successfully created test trips")
def setUp(self): "set up trip" super(TripDeleteViewTests, self).setUp() self.trip = milkman.deliver(Trip) self.addCleanup(self.trip.delete) self.url = reverse("trips:delete", kwargs={"pk": self.trip.pk}) self.trip.fully_authorize(self.user)
def test_move_nested_tag_to_root_no_sibling(self): """ Passing parent_tag_id=0 should move the tag to root """ tag_2 = milkman.deliver(GlobalTag, name="tag2") nested_project_tag = self.projecttag.add_child( global_tag=tag_2, project=self.project ) self._sign_in(self.admin) request = MoveProjectTagContainer.combined_message_class( project_id=self.project.pk, project_tag_id=nested_project_tag.pk, parent_tag_id=0 ) with self.assertNumQueries(11): response = self.api.projecttag_move(request) nested_project_tag = self.reload(nested_project_tag) self.assertTrue(nested_project_tag.is_root()) self.assertFalse(nested_project_tag.is_child_of(self.projecttag)) self.assertEqual(nested_project_tag, ProjectTag.get_last_root_node())
def test_options(self): self.assertTrue('OPTIONS' in ArticleResource.allowed_methods) uri = self.reverse('author-test-book-article', book=self.book.pk) response = self.client.options(uri, data=dict(author=self.author.pk)) self.assertContains(response, 'OK') author = milkman.deliver('main.author') response = self.client.options(uri, data=dict(author=author.pk)) self.assertContains(response, 'OK')
def create_page(self, **kwargs): letters = list(string.letters) random.shuffle(letters) random_name = ''.join(letters[:10]) page_kwargs = {'name' : random_name} page_kwargs.update(kwargs) return milkman.deliver(Page, **page_kwargs)
def setUp(self): settings.TEST = True cache.clear() # johnny_cache.disable() self.page = milkman.deliver(WebPage, slug='test-page', title="Test page") self.user = User.objects.create_user(username='******', email='*****@*****.**', password='******') self.client.login(username='******', password='******')
def test_simply(self): from adrest.utils.serializer import BaseSerializer from .models import Task user = milkman.deliver('auth.User', username="******") data = [milkman.deliver(Task, user=user), milkman.deliver(Task, user=user), 28, 'string'] serializer = BaseSerializer(_exclude='fake', _include='username', user=dict( _fields='email')) self.assertEqual(serializer.options['_exclude'], set(['fake'])) out = serializer.to_simple(data) self.assertEqual(out[0]['fields']['username'], data[0].user.username) # Test m2o serialization serializer = BaseSerializer(_include="task_set", task_set=dict( _fields=[])) out = serializer.to_simple(user) self.assertEquals(len(out['fields']['task_set']), 2) for task in out['fields']['task_set']: self.assertEquals(task['fields']['user'], user.pk) self.assertTrue('title' in task['fields'].keys())
def test_multiple_sorting(self): testuser = milkman.deliver(User) testuser.set_password("letmein") testuser.save() self.create_entries(3, user=testuser) self.assertEqual(LogEntry.objects.count(), 6) self.assertViewRenders(""" {% sort objects with "objects" as objects %} {% sort others with "others" as others %} {{ objects|sorter_tests_pks }}.{{ others|sorter_tests_pks }} """, "3.2.1.6.5.4", {"sort_objects": "-id", "sort_others": "-id"}, objects=LogEntry.objects.exclude(user=testuser), others=LogEntry.objects.filter(user=testuser))
def setUp(self): """ Create test tree """ root1 = milkman.deliver(Page) page11 = milkman.deliver(Page, parent=root1) page12 = milkman.deliver(Page, parent=root1) page111 = milkman.deliver(Page, parent=page11) page1111 = milkman.deliver(Page, parent=page111) page1112 = milkman.deliver(Page, parent=page111) self.__dict__.update(locals())
def handle(self, *args, **options): amount = int(args[0]) for i in range(amount): gender = random.choice((User.GENDERS.male, User.GENDERS.female)) user = milkman.deliver('users.user', email="test_{0}@mail.com".format(i), provider="facebook", birthday=random_date( datetime.now()-timedelta(days=70*365), datetime.now()-timedelta(days=18*365) ), gender=gender, first_name=str(i), last_name="_" + str(gender) ) self.stdout.write("Created user '{0}'".format(user)) self.stdout.write("Successfully created test users")
def setUp(self): self.show = milkman.deliver(Show, title="snowprayers") self.show.save() self.episodes = [] for i in range(0, 10): episode = milkman.deliver(Episode, show=self.show, title="Episode 1") episode.save() self.episodes.append(episode) self.episode = milkman.deliver(Episode, show=self.show, title="Episode") self.episode.save() long_title = "".join(["x" for i in range(51)]) self.long_episode1 = milkman.deliver(Episode, show=self.show, title=long_title) self.long_episode1.save() self.long_episode2 = milkman.deliver(Episode, show=self.show, title=long_title) self.long_episode2.save() self.enclosure = milkman.deliver(Enclosure, episode=self.episodes[0]) self.enclosure.save()
def setUp(self): super(ViewTests, self).setUp() self.user = milkman.deliver(User) self.user.set_password('password') self.user.save() self.client.login(username=self.user.username, password='******')
def test_m2m_model_self(self): child = milkman.deliver(PsychoChild) self.assertEquals(child.alter_egos.all().count(), 1) self.assertEquals(PsychoChild.objects.all().count(), 2)
def test_m2m_related_explicit_values(self): aunt = milkman.deliver(Aunt, uncles__name='foo') self.assertEqual(1, len(aunt.uncles.all())) self.assertEqual(aunt.uncles.all()[0].name, 'foo')
def setUp(self): super(UserRoleTests, self).setUp() self.user = milkman.deliver(User) set_user_role(self.user, roles.manager)
def setUp(self): self.api_page_json = os.path.join(self.get_api_url('page'), '?format=json') self.page = milkman.deliver(WebPage, slug='test-page', title='Test page')
def deliver(self, *args, **kwargs): obj = milkman.deliver(*args, **kwargs) self.addCleanup(obj.delete) return obj
def setUp(self): self.jacket = milkman.deliver(Item) self.trousers = milkman.deliver(Item)
def setUp(self): self.jacket = milkman.deliver(Item) self.trousers = milkman.deliver(Item) self.item_admin = ItemAdmin(Item, site) self.notification_inline = NotificationInline(self.item_admin, site)
def setUp(self): self.jacket = milkman.deliver(Item, name="jacket") self.url = "/lost_found/jacket/" self.client = Client() self.response = self.client.get(self.url, follow=True)
def setUp(self): self.url = "/lost_found/" self.client = Client() self.jacket = milkman.deliver(Item, lost=date(1, 1, 1)) self.trousers = milkman.deliver(Item, lost=date(1, 1, 2)) self.response = self.client.get(self.url, follow=True)
def setUp(self): self.hi = milkman.deliver(Notification) self.hello = milkman.deliver(Notification)