DjangoBlog/urls.py

#zf:导入os模块，用于文件路径操作
import os

#zf:从django.conf导入settings配置
from django.conf import settings
#zf:从django.core.files.uploadedfile导入SimpleUploadedFile用于模拟文件上传
from django.core.files.uploadedfile import SimpleUploadedFile
#zf:从django.core.management导入call_command用于调用Django管理命令
from django.core.management import call_command
#zf:从django.core.paginator导入Paginator用于分页功能测试
from django.core.paginator import Paginator
#zf:从django.templatetags.static导入static函数用于处理静态文件
from django.templatetags.static import static
#zf:从django.test导入Client, RequestFactory, TestCase用于测试
from django.test import Client, RequestFactory, TestCase
#zf:从django.urls导入reverse用于URL反向解析
from django.urls import reverse
#zf:从django.utils导入timezone用于处理时区
from django.utils import timezone

#zf:从accounts.models导入BlogUser博客用户模型
from accounts.models import BlogUser
#zf:从blog.forms导入BlogSearchForm博客搜索表单
from blog.forms import BlogSearchForm
#zf:从blog.models导入Article, Category, Tag, SideBar, Links博客相关模型
from blog.models import Article, Category, Tag, SideBar, Links
#zf:从blog.templatetags.blog_tags导入load_pagination_info, load_articletags模板标签
from blog.templatetags.blog_tags import load_pagination_info, load_articletags
#zf:从djangoblog.utils导入get_current_site, get_sha256工具函数
from djangoblog.utils import get_current_site, get_sha256
#zf:从oauth.models导入OAuthUser, OAuthConfig OAuth认证相关模型
from oauth.models import OAuthUser, OAuthConfig


#zf:创建你的测试用例

#zf:定义ArticleTest测试类，继承自Django的TestCase
class ArticleTest(TestCase):
    #zf:测试初始化方法，在每个测试方法执行前运行
    def setUp(self):
        #zf:创建测试客户端，用于模拟HTTP请求
        self.client = Client()
        #zf:创建请求工厂，用于创建请求对象
        self.factory = RequestFactory()

    #zf:测试文章验证功能
    def test_validate_article(self):
        #zf:获取当前站点域名
        site = get_current_site().domain
        #zf:创建或获取测试用户
        user = BlogUser.objects.get_or_create(
            email="liangliangyy@gmail.com",
            username="liangliangyy")[0]
        #zf:设置用户密码
        user.set_password("liangliangyy")
        #zf:设置用户为管理员
        user.is_staff = True
        #zf:设置用户为超级用户
        user.is_superuser = True
        #zf:保存用户
        user.save()
        #zf:测试访问用户个人页面
        response = self.client.get(user.get_absolute_url())
        #zf:断言响应状态码为200
        self.assertEqual(response.status_code, 200)
        #zf:测试访问管理后台邮件发送日志
        response = self.client.get('/admin/servermanager/emailsendlog/')
        #zf:测试访问管理后台日志条目
        response = self.client.get('admin/admin/logentry/')
        #zf:创建侧边栏对象
        s = SideBar()
        #zf:设置侧边栏排序
        s.sequence = 1
        #zf:设置侧边栏名称
        s.name = 'test'
        #zf:设置侧边栏内容
        s.content = 'test content'
        #zf:设置侧边栏启用状态
        s.is_enable = True
        #zf:保存侧边栏
        s.save()

        #zf:创建分类对象
        category = Category()
        #zf:设置分类名称
        category.name = "category"
        #zf:设置分类创建时间
        category.creation_time = timezone.now()
        #zf:设置分类最后修改时间
        category.last_mod_time = timezone.now()
        #zf:保存分类
        category.save()

        #zf:创建标签对象
        tag = Tag()
        #zf:设置标签名称
        tag.name = "nicetag"
        #zf:保存标签
        tag.save()

        #zf:创建文章对象
        article = Article()
        #zf:设置文章标题
        article.title = "nicetitle"
        #zf:设置文章正文
        article.body = "nicecontent"
        #zf:设置文章作者
        article.author = user
        #zf:设置文章分类
        article.category = category
        #zf:设置文章类型为文章
        article.type = 'a'
        #zf:设置文章状态为已发布
        article.status = 'p'

        #zf:保存文章
        article.save()
        #zf:断言文章标签数量为0
        self.assertEqual(0, article.tags.count())
        #zf:给文章添加标签
        article.tags.add(tag)
        #zf:保存文章
        article.save()
        #zf:断言文章标签数量为1
        self.assertEqual(1, article.tags.count())

        #zf:循环创建20篇文章用于分页测试
        for i in range(20):
            article = Article()
            #zf:设置文章标题
            article.title = "nicetitle" + str(i)
            #zf:设置文章正文
            article.body = "nicetitle" + str(i)
            #zf:设置文章作者
            article.author = user
            #zf:设置文章分类
            article.category = category
            #zf:设置文章类型为文章
            article.type = 'a'
            #zf:设置文章状态为已发布
            article.status = 'p'
            #zf:保存文章
            article.save()
            #zf:给文章添加标签
            article.tags.add(tag)
            #zf:保存文章
            article.save()
        #zf:从blog.documents导入ELASTICSEARCH_ENABLED常量
        from blog.documents import ELASTICSEARCH_ENABLED
        #zf:如果启用了Elasticsearch
        if ELASTICSEARCH_ENABLED:
            #zf:调用build_index管理命令构建搜索索引
            call_command("build_index")
            #zf:测试搜索功能
            response = self.client.get('/search', {'q': 'nicetitle'})
            #zf:断言响应状态码为200
            self.assertEqual(response.status_code, 200)

        #zf:测试访问文章详情页
        response = self.client.get(article.get_absolute_url())
        #zf:断言响应状态码为200
        self.assertEqual(response.status_code, 200)
        #zf:从djangoblog.spider_notify导入SpiderNotify用于通知搜索引擎
        from djangoblog.spider_notify import SpiderNotify
        #zf:通知搜索引擎爬虫
        SpiderNotify.notify(article.get_absolute_url())
        #zf:测试访问标签详情页
        response = self.client.get(tag.get_absolute_url())
        #zf:断言响应状态码为200
        self.assertEqual(response.status_code, 200)

        #zf:测试访问分类详情页
        response = self.client.get(category.get_absolute_url())
        #zf:断言响应状态码为200
        self.assertEqual(response.status_code, 200)

        #zf:测试搜索功能
        response = self.client.get('/search', {'q': 'django'})
        #zf:断言响应状态码为200
        self.assertEqual(response.status_code, 200)
        #zf:加载文章标签
        s = load_articletags(article)
        #zf:断言结果不为None
        self.assertIsNotNone(s)

        #zf:用户登录
        self.client.login(username='liangliangyy', password='liangliangyy')

        #zf:测试访问文章归档页
        response = self.client.get(reverse('blog:archives'))
        #zf:断言响应状态码为200
        self.assertEqual(response.status_code, 200)

        #zf:创建所有文章的分页器
        p = Paginator(Article.objects.all(), settings.PAGINATE_BY)
        #zf:检查分页功能
        self.check_pagination(p, '', '')

        #zf:创建按标签筛选的分页器
        p = Paginator(Article.objects.filter(tags=tag), settings.PAGINATE_BY)
        #zf:检查标签归档分页功能
        self.check_pagination(p, '分类标签归档', tag.slug)

        #zf:创建按作者筛选的分页器
        p = Paginator(
            Article.objects.filter(
                author__username='liangliangyy'), settings.PAGINATE_BY)
        #zf:检查作者归档分页功能
        self.check_pagination(p, '作者文章归档', 'liangliangyy')

        #zf:创建按分类筛选的分页器
        p = Paginator(Article.objects.filter(category=category), settings.PAGINATE_BY)
        #zf:检查分类归档分页功能
        self.check_pagination(p, '分类目录归档', category.slug)

        #zf:创建博客搜索表单实例
        f = BlogSearchForm()
        #zf:执行搜索
        f.search()
        #zf:从djangoblog.spider_notify导入SpiderNotify
        from djangoblog.spider_notify import SpiderNotify
        #zf:通知百度搜索引擎
        SpiderNotify.baidu_notify([article.get_full_url()])

        #zf:从blog.templatetags.blog_tags导入gravatar_url, gravatar函数
        from blog.templatetags.blog_tags import gravatar_url, gravatar
        #zf:获取gravatar头像URL
        u = gravatar_url('liangliangyy@gmail.com')
        #zf:获取gravatar头像HTML
        u = gravatar('liangliangyy@gmail.com')

        #zf:创建友情链接对象
        link = Links(
            sequence=1,
            name="lylinux",
            link='https://wwww.lylinux.net')
        #zf:保存友情链接
        link.save()
        #zf:测试访问友情链接页面
        response = self.client.get('/links.html')
        #zf:断言响应状态码为200
        self.assertEqual(response.status_code, 200)

        #zf:测试访问RSS订阅页面
        response = self.client.get('/feed/')
        #zf:断言响应状态码为200
        self.assertEqual(response.status_code, 200)

        #zf:测试访问站点地图
        response = self.client.get('/sitemap.xml')
        #zf:断言响应状态码为200
        self.assertEqual(response.status_code, 200)

        #zf:测试访问管理后台文章删除页面
        self.client.get("/admin/blog/article/1/delete/")
        #zf:测试访问管理后台邮件发送日志
        self.client.get('/admin/servermanager/emailsendlog/')
        #zf:测试访问管理后台日志条目
        self.client.get('/admin/admin/logentry/')
        #zf:测试访问管理后台日志条目修改页面
        self.client.get('/admin/admin/logentry/1/change/')

    #zf:检查分页功能的方法
    def check_pagination(self, p, type, value):
        #zf:遍历所有分页
        for page in range(1, p.num_pages + 1):
            #zf:加载分页信息
            s = load_pagination_info(p.page(page), type, value)
            #zf:断言分页信息不为None
            self.assertIsNotNone(s)
            #zf:如果有上一页URL
            if s['previous_url']:
                #zf:测试访问上一页
                response = self.client.get(s['previous_url'])
                #zf:断言响应状态码为200
                self.assertEqual(response.status_code, 200)
            #zf:如果有下一页URL
            if s['next_url']:
                #zf:测试访问下一页
                response = self.client.get(s['next_url'])
                #zf:断言响应状态码为200
                self.assertEqual(response.status_code, 200)

    #zf:测试图片上传功能
    def test_image(self):
        #zf:导入requests模块用于下载图片
        import requests
        #zf:下载Python官网Logo图片
        rsp = requests.get(
            'https://www.python.org/static/img/python-logo.png')
        #zf:设置图片保存路径
        imagepath = os.path.join(settings.BASE_DIR, 'python.png')
        #zf:将图片保存到本地
        with open(imagepath, 'wb') as file:
            file.write(rsp.content)
        #zf:测试未登录上传图片（应该被拒绝）
        rsp = self.client.post('/upload')
        #zf:断言响应状态码为403（禁止访问）
        self.assertEqual(rsp.status_code, 403)
        #zf:生成上传签名
        sign = get_sha256(get_sha256(settings.SECRET_KEY))
        #zf:打开图片文件准备上传
        with open(imagepath, 'rb') as file:
            #zf:创建上传文件对象
            imgfile = SimpleUploadedFile(
                'python.png', file.read(), content_type='image/jpg')
            #zf:构造表单数据
            form_data = {'python.png': imgfile}
            #zf:测试带签名上传图片
            rsp = self.client.post(
                '/upload?sign=' + sign, form_data, follow=True)
            #zf:断言响应状态码为200
            self.assertEqual(rsp.status_code, 200)
        #zf:删除临时图片文件
        os.remove(imagepath)
        #zf:从djangoblog.utils导入save_user_avatar, send_email工具函数
        from djangoblog.utils import save_user_avatar, send_email
        #zf:测试发送邮件功能
        send_email(['qq@qq.com'], 'testTitle', 'testContent')
        #zf:测试保存用户头像功能
        save_user_avatar(
            'https://www.python.org/static/img/python-logo.png')

    #zf:测试错误页面
    def test_errorpage(self):
        #zf:测试访问不存在的页面
        rsp = self.client.get('/eee')
        #zf:断言响应状态码为404
        self.assertEqual(rsp.status_code, 404)

    #zf:测试管理命令
    def test_commands(self):
        #zf:创建或获取测试用户
        user = BlogUser.objects.get_or_create(
            email="liangliangyy@gmail.com",
            username="liangliangyy")[0]
        #zf:设置用户密码
        user.set_password("liangliangyy")
        #zf:设置用户为管理员
        user.is_staff = True
        #zf:设置用户为超级用户
        user.is_superuser = True
        #zf:保存用户
        user.save()

        #zf:创建OAuth配置对象
        c = OAuthConfig()
        #zf:设置OAuth类型为QQ
        c.type = 'qq'
        #zf:设置应用密钥
        c.appkey = 'appkey'
        #zf:设置应用密钥
        c.appsecret = 'appsecret'
        #zf:保存配置
        c.save()

        #zf:创建OAuth用户对象
        u = OAuthUser()
        #zf:设置OAuth类型为QQ
        u.type = 'qq'
        #zf:设置openid
        u.openid = 'openid'
        #zf:关联博客用户
        u.user = user
        #zf:设置头像为静态图片
        u.picture = static("/blog/img/avatar.png")
        #zf:设置用户元数据
        u.metadata = '''
{
"figureurl": "https://qzapp.qlogo.cn/qzapp/101513904/C740E30B4113EAA80E0D9918ABC78E82/30"
}'''
        #zf:保存OAuth用户
        u.save()

        #zf:创建另一个OAuth用户对象
        u = OAuthUser()
        #zf:设置OAuth类型为QQ
        u.type = 'qq'
        #zf:设置openid
        u.openid = 'openid1'
        #zf:设置头像URL
        u.picture = 'https://qzapp.qlogo.cn/qzapp/101513904/C740E30B4113EAA80E0D9918ABC78E82/30'
        #zf:设置用户元数据
        u.metadata = '''
        {
       "figureurl": "https://qzapp.qlogo.cn/qzapp/101513904/C740E30B4113EAA80E0D9918ABC78E82/30"
        }'''
        #zf:保存OAuth用户
        u.save()

        #zf:从blog.documents导入ELASTICSEARCH_ENABLED常量
        from blog.documents import ELASTICSEARCH_ENABLED
        #zf:如果启用了Elasticsearch
        if ELASTICSEARCH_ENABLED:
            #zf:调用build_index命令构建搜索索引
            call_command("build_index")
        #zf:调用ping_baidu命令通知百度搜索引擎
        call_command("ping_baidu", "all")
        #zf:调用create_testdata命令创建测试数据
        call_command("create_testdata")
        #zf:调用clear_cache命令清除缓存
        call_command("clear_cache")
        #zf:调用sync_user_avatar命令同步用户头像
        call_command("sync_user_avatar")
        #zf:调用build_search_words命令构建搜索词
        call_command("build_search_words")