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='user', email='[email protected]', password='pass')
        self.client.login(username='user', password='pass')

        self.rf = RequestFactory()

    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 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 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_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 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):
     "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 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 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 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='user',
            email='[email protected]', password='pass')
        self.client.login(username='user', password='pass')

    def test_simply(self):
        from adrest.utils.serializer import BaseSerializer
        from .models import Task
        user = milkman.deliver('auth.User', username="testusername")
        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 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')