Python utils.datetime函数代码示例

 def test_previous_next_entry_in_one_query(self):
     site = Site.objects.get_current()
     self.entry.status = PUBLISHED
     self.entry.save()
     self.entry.sites.add(site)
     with self.assertNumQueries(1):
         self.assertFalse(self.entry.previous_entry)
         self.assertFalse(self.entry.next_entry)
         # Reload to check the cache
         self.assertFalse(self.entry.previous_entry)
         self.assertFalse(self.entry.next_entry)
     params = {'title': 'My second entry',
               'content': 'My second content',
               'slug': 'my-second-entry',
               'creation_date': datetime(2001, 1, 1),
               'status': PUBLISHED}
     self.second_entry = Entry.objects.create(**params)
     self.second_entry.sites.add(site)
     params = {'title': 'My third entry',
               'content': 'My third content',
               'slug': 'my-third-entry',
               'creation_date': datetime(2050, 1, 1),
               'status': PUBLISHED}
     self.third_entry = Entry.objects.create(**params)
     self.third_entry.sites.add(site)
     del self.entry.previous_next  # Invalidate the cached property
     with self.assertNumQueries(1):
         self.assertEqual(self.entry.previous_entry, self.second_entry)
         self.assertEqual(self.entry.next_entry, self.third_entry)
         # Reload to check the cache
         self.assertEqual(self.entry.previous_entry, self.second_entry)
         self.assertEqual(self.entry.next_entry, self.third_entry)

    def setUp(self):
        # Create data
        self.webmaster = Author.objects.create_superuser(
            username='webmaster',
            email='[email protected]',
            password='password')
        self.contributor = Author.objects.create_user(
            username='contributor',
            email='[email protected]',
            password='password')
        self.site = Site.objects.get_current()
        self.categories = [
            Category.objects.create(title='Category 1',
                                    slug='category-1'),
            Category.objects.create(title='Category 2',
                                    slug='category-2')]
        params = {'title': 'My entry 1', 'content': 'My content 1',
                  'tags': 'zinnia, test', 'slug': 'my-entry-1',
                  'creation_date': datetime(2010, 1, 1, 12),
                  'status': PUBLISHED}
        self.entry_1 = Entry.objects.create(**params)
        self.entry_1.authors.add(self.webmaster)
        self.entry_1.categories.add(*self.categories)
        self.entry_1.sites.add(self.site)

        params = {'title': 'My entry 2', 'content': 'My content 2',
                  'creation_date': datetime(2010, 3, 15),
                  'tags': 'zinnia, test', 'slug': 'my-entry-2'}
        self.entry_2 = Entry.objects.create(**params)
        self.entry_2.authors.add(self.webmaster)
        self.entry_2.categories.add(self.categories[0])
        self.entry_2.sites.add(self.site)
        # Instanciating the server proxy
        self.server = ServerProxy('http://localhost:8000/xmlrpc/',
                                  transport=TestTransport())

    def setUp(self):
        self.site = Site.objects.get_current()
        self.author = User.objects.create_superuser(
            username='admin', email='[email protected]', password='password')
        self.category = Category.objects.create(title='Tests', slug='tests')
        params = {'title': 'Test 1',
                  'content': 'First test entry published',
                  'slug': 'test-1',
                  'tags': 'tests',
                  'creation_date': datetime(2010, 1, 1, 13, 25),
                  'status': PUBLISHED}
        entry = Entry.objects.create(**params)
        entry.sites.add(self.site)
        entry.categories.add(self.category)
        entry.authors.add(self.author)

        params = {'title': 'Test 2',
                  'content': 'Second test entry published',
                  'slug': 'test-2',
                  'tags': 'tests',
                  'creation_date': datetime(2010, 6, 1, 12, 12),
                  'status': PUBLISHED}
        entry = Entry.objects.create(**params)
        entry.sites.add(self.site)
        entry.categories.add(self.category)
        entry.authors.add(self.author)

    def setUp(self):
        self.site = Site.objects.get_current()
        self.author = Author.objects.create_user(username="admin", email="[email protected]", password="password")
        self.category = Category.objects.create(title="Tests", slug="tests")
        params = {
            "title": "Test 1",
            "content": "First test entry published",
            "slug": "test-1",
            "tags": "tests",
            "creation_date": datetime(2010, 1, 1, 13, 25),
            "status": PUBLISHED,
        }
        entry = Entry.objects.create(**params)
        entry.sites.add(self.site)
        entry.categories.add(self.category)
        entry.authors.add(self.author)

        params = {
            "title": "Test 2",
            "content": "Second test entry published",
            "slug": "test-2",
            "tags": "tests",
            "creation_date": datetime(2010, 6, 1, 12, 12),
            "status": PUBLISHED,
        }
        entry = Entry.objects.create(**params)
        entry.sites.add(self.site)
        entry.categories.add(self.category)
        entry.authors.add(self.author)

    def setUp(self):
        disconnect_entry_signals()
        disconnect_discussion_signals()
        self.site = Site.objects.get_current()
        self.author = Author.objects.create_user(username='admin',
                                                 email='[email protected]',
                                                 password='password')
        self.category = Category.objects.create(title='Tests', slug='tests')
        params = {'title': 'Test 1',
                  'content': 'First test entry published',
                  'slug': 'test-1',
                  'tags': 'tests',
                  'publication_date': datetime(2010, 1, 1, 23, 0),
                  'status': PUBLISHED}
        entry = Entry.objects.create(**params)
        entry.sites.add(self.site)
        entry.categories.add(self.category)
        entry.authors.add(self.author)
        self.first_entry = entry

        params = {'title': 'Test 2',
                  'content': 'Second test entry published',
                  'slug': 'test-2',
                  'tags': 'tests',
                  'publication_date': datetime(2010, 5, 31, 23, 00),
                  'status': PUBLISHED}
        entry = Entry.objects.create(**params)
        entry.sites.add(self.site)
        entry.categories.add(self.category)
        entry.authors.add(self.author)
        self.second_entry = entry

    def test_edit_post(self):
        post = post_structure(self.entry_2, self.site)
        self.assertRaises(Fault, self.server.metaWeblog.editPost,
                          1, 'contributor', 'password', post, 1)
        new_post_id = self.server.metaWeblog.newPost(
            1, 'webmaster', 'password', post, 0)

        entry = Entry.objects.get(pk=new_post_id)
        self.assertEqual(entry.title, self.entry_2.title)
        self.assertEqual(entry.content, self.entry_2.html_content)
        self.assertEqual(entry.excerpt, self.entry_2.excerpt)
        self.assertEqual(entry.slug, self.entry_2.slug)
        self.assertEqual(entry.status, DRAFT)
        self.assertEqual(entry.password, self.entry_2.password)
        self.assertEqual(entry.comment_enabled, True)
        self.assertEqual(entry.pingback_enabled, True)
        self.assertEqual(entry.categories.count(), 1)
        self.assertEqual(entry.authors.count(), 1)
        self.assertEqual(entry.authors.all()[0], self.webmaster)
        self.assertEqual(entry.creation_date, self.entry_2.creation_date)
        self.assertEqual(entry.publication_date, self.entry_2.creation_date)

        entry.title = 'Title edited'
        entry.creation_date = datetime(2000, 1, 1)
        post = post_structure(entry, self.site)
        post['categories'] = ''
        post['description'] = 'Content edited'
        post['mt_excerpt'] = 'Content edited'
        post['wp_slug'] = 'slug-edited'
        post['wp_password'] = 'password'
        post['mt_allow_comments'] = 2
        post['mt_allow_pings'] = 0

        response = self.server.metaWeblog.editPost(
            new_post_id, 'webmaster', 'password', post, 1)
        self.assertEqual(response, True)
        entry = Entry.objects.get(pk=new_post_id)
        self.assertEqual(entry.title, post['title'])
        self.assertEqual(entry.content, post['description'])
        self.assertEqual(entry.excerpt, post['mt_excerpt'])
        self.assertEqual(entry.slug, 'slug-edited')
        self.assertEqual(entry.status, PUBLISHED)
        self.assertEqual(entry.password, 'password')
        self.assertEqual(entry.comment_enabled, False)
        self.assertEqual(entry.pingback_enabled, False)
        self.assertEqual(entry.categories.count(), 0)
        self.assertEqual(entry.creation_date, datetime(2000, 1, 1))
        self.assertEqual(entry.publication_date, datetime(2000, 1, 1))

        del post['dateCreated']
        post['wp_author_id'] = self.contributor.pk

        response = self.server.metaWeblog.editPost(
            new_post_id, 'webmaster', 'password', post, 1)
        entry = Entry.objects.get(pk=new_post_id)
        self.assertEqual(entry.authors.count(), 1)
        self.assertEqual(entry.authors.all()[0], self.contributor)
        self.assertEqual(entry.creation_date, datetime(2000, 1, 1))
        self.assertEqual(entry.publication_date, datetime(2000, 1, 1))

    def setUp(self):
        disconnect_entry_signals()
        disconnect_discussion_signals()
        # Clear the cache of user flagger to avoid error on MySQL
        get_user_flagger.cache_clear()
        # Use default URL shortener backend, to avoid networks errors
        self.original_shortener = shortener_settings.URL_SHORTENER_BACKEND
        shortener_settings.URL_SHORTENER_BACKEND = "zinnia.url_shortener." "backends.default"
        # Set up a stub around urlopen
        import zinnia.xmlrpc.pingback

        self.original_urlopen = zinnia.xmlrpc.pingback.urlopen
        zinnia.xmlrpc.pingback.urlopen = self.fake_urlopen
        # Set a short template for entry_detail to avoid rendering errors
        setup_test_template_loader(
            {
                "zinnia/entry_detail.html": "<html><head><title>{{ object.title }}</title></head>"
                "<body>{{ object.html_content|safe }}</body></html>",
                "404.html": "404",
            }
        )
        # Preparing site
        self.site = Site.objects.get_current()
        # Creating tests entries
        self.author = Author.objects.create_user(username="webmaster", email="[email protected]")
        self.category = Category.objects.create(title="test", slug="test")
        params = {
            "title": "My first entry",
            "content": "My first content",
            "slug": "my-first-entry",
            "creation_date": datetime(2010, 1, 1, 12),
            "status": PUBLISHED,
        }
        self.first_entry = Entry.objects.create(**params)
        self.first_entry.sites.add(self.site)
        self.first_entry.categories.add(self.category)
        self.first_entry.authors.add(self.author)

        params = {
            "title": "My second entry",
            "content": "My second content with link "
            'to <a href="http://%s%s">first entry</a>'
            " and other links : %s %s."
            % (
                self.site.domain,
                self.first_entry.get_absolute_url(),
                "http://example.com/error-404/",
                "http://external/",
            ),
            "slug": "my-second-entry",
            "creation_date": datetime(2010, 1, 1, 12),
            "status": PUBLISHED,
        }
        self.second_entry = Entry.objects.create(**params)
        self.second_entry.sites.add(self.site)
        self.second_entry.categories.add(self.category)
        self.second_entry.authors.add(self.author)
        # Instanciating the server proxy
        self.server = ServerProxy("http://example.com/xmlrpc/", transport=TestTransport())

 def test_is_actual(self):
     self.assertTrue(self.entry.is_actual)
     self.entry.start_publication = datetime(2020, 3, 15)
     self.assertFalse(self.entry.is_actual)
     self.entry.start_publication = timezone.now()
     self.assertTrue(self.entry.is_actual)
     self.entry.end_publication = datetime(2000, 3, 15)
     self.assertFalse(self.entry.is_actual)

 def test_archives_entries_tree_with_timezone(self):
     template = Template('{% load zinnia %}'
                         '{% get_archives_entries_tree %}')
     self.create_published_entry_at(datetime(2014, 1, 1, 12, 0))
     self.create_published_entry_at(datetime(2014, 1, 31, 23, 0))
     output = template.render(Context())
     self.assertTrue('/2014/01/01/' in output)
     self.assertTrue('/2014/02/01/' in output)

    def setUp(self):
        disconnect_entry_signals()
        disconnect_discussion_signals()
        # Clean the memoization of user flagger to avoid error on MySQL
        try:
            del user_flagger_[()]
        except KeyError:
            pass
        # Use default URL shortener backend, to avoid networks errors
        self.original_shortener = shortener_settings.URL_SHORTENER_BACKEND
        shortener_settings.URL_SHORTENER_BACKEND = 'zinnia.url_shortener.'\
                                                   'backends.default'
        # Set up a stub around urlopen
        import zinnia.xmlrpc.pingback
        self.original_urlopen = zinnia.xmlrpc.pingback.urlopen
        zinnia.xmlrpc.pingback.urlopen = self.fake_urlopen
        # Set a short template for entry_detail to avoid rendering errors
        setup_test_template_loader(
            {'zinnia/entry_detail.html':
             '<html><head><title>{{ object.title }}</title></head>'
             '<body>{{ object.html_content|safe }}</body></html>',
             '404.html': '404'})
        # Preparing site
        self.site = Site.objects.get_current()
        # Creating tests entries
        self.author = Author.objects.create_user(username='webmaster',
                                                 email='[email protected]')
        self.category = Category.objects.create(title='test', slug='test')
        params = {'title': 'My first entry',
                  'content': 'My first content',
                  'slug': 'my-first-entry',
                  'creation_date': datetime(2010, 1, 1, 12),
                  'status': PUBLISHED}
        self.first_entry = Entry.objects.create(**params)
        self.first_entry.sites.add(self.site)
        self.first_entry.categories.add(self.category)
        self.first_entry.authors.add(self.author)

        params = {'title': 'My second entry',
                  'content': 'My second content with link '
                  'to <a href="http://%s%s">first entry</a>'
                  ' and other links : %s %s.' % (
                      self.site.domain,
                      self.first_entry.get_absolute_url(),
                      'http://example.com/error-404/',
                      'http://external/'),
                  'slug': 'my-second-entry',
                  'creation_date': datetime(2010, 1, 1, 12),
                  'status': PUBLISHED}
        self.second_entry = Entry.objects.create(**params)
        self.second_entry.sites.add(self.site)
        self.second_entry.categories.add(self.category)
        self.second_entry.authors.add(self.author)
        # Instanciating the server proxy
        self.server = ServerProxy('http://example.com/xmlrpc/',
                                  transport=TestTransport())

 def test_calendar_entries_no_timezone(self):
     template = Template('{% load zinnia %}'
                         '{% get_calendar_entries 2014 1 %}')
     self.create_published_entry_at(datetime(2014, 1, 1, 12, 0))
     self.create_published_entry_at(datetime(2014, 1, 1, 23, 0))
     self.create_published_entry_at(datetime(2012, 12, 31, 23, 0))
     self.create_published_entry_at(datetime(2014, 1, 31, 23, 0))
     output = template.render(Context())
     self.assertTrue('/2014/01/01/' in output)
     self.assertTrue('/2014/01/02/' not in output)
     self.assertTrue('/2012/12/' in output)
     self.assertTrue('/2014/02/' not in output)

    def test_edit_post(self):
        post = post_structure(self.entry_2, self.site)
        self.assertRaises(Fault, self.server.metaWeblog.editPost, 1, "contributor", "password", post, 1)
        new_post_id = self.server.metaWeblog.newPost(1, "webmaster", "password", post, 0)

        entry = Entry.objects.get(pk=new_post_id)
        self.assertEqual(entry.title, self.entry_2.title)
        self.assertEqual(entry.content, self.entry_2.html_content)
        self.assertEqual(entry.excerpt, self.entry_2.excerpt)
        self.assertEqual(entry.slug, self.entry_2.slug)
        self.assertEqual(entry.status, DRAFT)
        self.assertEqual(entry.password, self.entry_2.password)
        self.assertEqual(entry.comment_enabled, True)
        self.assertEqual(entry.pingback_enabled, True)
        self.assertEqual(entry.categories.count(), 1)
        self.assertEqual(entry.authors.count(), 1)
        self.assertEqual(entry.authors.all()[0], self.webmaster)
        self.assertEqual(entry.creation_date, self.entry_2.creation_date)

        entry.title = "Title edited"
        entry.creation_date = datetime(2000, 1, 1)
        post = post_structure(entry, self.site)
        post["categories"] = ""
        post["description"] = "Content edited"
        post["mt_excerpt"] = "Content edited"
        post["wp_slug"] = "slug-edited"
        post["wp_password"] = "password"
        post["mt_allow_comments"] = 2
        post["mt_allow_pings"] = 0

        response = self.server.metaWeblog.editPost(new_post_id, "webmaster", "password", post, 1)
        self.assertEqual(response, True)
        entry = Entry.objects.get(pk=new_post_id)
        self.assertEqual(entry.title, post["title"])
        self.assertEqual(entry.content, post["description"])
        self.assertEqual(entry.excerpt, post["mt_excerpt"])
        self.assertEqual(entry.slug, "slug-edited")
        self.assertEqual(entry.status, PUBLISHED)
        self.assertEqual(entry.password, "password")
        self.assertEqual(entry.comment_enabled, False)
        self.assertEqual(entry.pingback_enabled, False)
        self.assertEqual(entry.categories.count(), 0)
        self.assertEqual(entry.creation_date, datetime(2000, 1, 1))

        del post["dateCreated"]
        post["wp_author_id"] = self.contributor.pk

        response = self.server.metaWeblog.editPost(new_post_id, "webmaster", "password", post, 1)
        entry = Entry.objects.get(pk=new_post_id)
        self.assertEqual(entry.authors.count(), 1)
        self.assertEqual(entry.authors.all()[0], self.contributor)
        self.assertEqual(entry.creation_date, datetime(2000, 1, 1))

    def setUp(self):
        disconnect_entry_signals()
        disconnect_discussion_signals()
        # Clear the cache of user flagger to avoid error on MySQL
        get_user_flagger.cache_clear()
        # Use default URL shortener backend, to avoid networks errors
        self.original_shortener = shortener_settings.URL_SHORTENER_BACKEND
        shortener_settings.URL_SHORTENER_BACKEND = 'zinnia.url_shortener.'\
                                                   'backends.default'
        # Set up a stub around urlopen
        import zinnia.xmlrpc.pingback
        self.original_urlopen = zinnia.xmlrpc.pingback.urlopen
        zinnia.xmlrpc.pingback.urlopen = self.fake_urlopen
        # Set up a stub around zinnia.spam_checker
        import zinnia.spam_checker
        self.original_scb = zinnia.spam_checker.SPAM_CHECKER_BACKENDS
        zinnia.spam_checker.SPAM_CHECKER_BACKENDS = []
        # Preparing site
        self.site = Site.objects.get_current()
        # Creating tests entries
        self.author = Author.objects.create_user(username='webmaster',
                                                 email='[email protected]')
        self.category = Category.objects.create(title='test', slug='test')
        params = {'title': 'My first entry',
                  'content': 'My first content',
                  'slug': 'my-first-entry',
                  'publication_date': datetime(2010, 1, 1, 12),
                  'status': PUBLISHED}
        self.first_entry = Entry.objects.create(**params)
        self.first_entry.sites.add(self.site)
        self.first_entry.categories.add(self.category)
        self.first_entry.authors.add(self.author)

        params = {'title': 'My second entry',
                  'content': 'My second content with link '
                  'to <a href="http://%s%s">first entry</a>'
                  ' and other links : %s %s.' % (
                      self.site.domain,
                      self.first_entry.get_absolute_url(),
                      'http://example.com/error-404/',
                      'http://external/'),
                  'slug': 'my-second-entry',
                  'publication_date': datetime(2010, 1, 1, 12),
                  'status': PUBLISHED}
        self.second_entry = Entry.objects.create(**params)
        self.second_entry.sites.add(self.site)
        self.second_entry.categories.add(self.category)
        self.second_entry.authors.add(self.author)
        # Instanciating the server proxy
        self.server = ServerProxy('http://example.com/xmlrpc/',
                                  transport=TestTransport())

 def test_zinnia_entry_archive_month_with_timezone(self):
     response = self.check_publishing_context(
         '/2010/01/', 1, 2, 'entry_list', 3)
     self.assertTemplateUsed(
         response, 'zinnia/archives/2010/month/01/entry_archive_month.html')
     self.assertEqual(response.context['previous_month'], None)
     self.assertEqual(response.context['next_month'], date(2010, 6, 1))
     self.assertEqual(response.context['date_list'][0].date(),
                      datetime(2010, 1, 2).date())
     response = self.client.get('/2010/06/')
     self.assertEqual(response.context['previous_month'], date(2010, 1, 1))
     self.assertEqual(response.context['next_month'], None)
     self.assertEqual(response.context['date_list'][0].date(),
                      datetime(2010, 6, 1).date())

 def setUp(self):
     params = {'title': 'My entry',
               'content': 'My content',
               'tags': 'zinnia, test',
               'creation_date': datetime(2010, 1, 1),
               'slug': 'my-entry'}
     self.entry = Entry.objects.create(**params)