xhtm 0.2.0__tar.gz → 0.3.0__tar.gz

{xhtm-0.2.0 → xhtm-0.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: xhtm
-Version: 0.2.0
+Version: 0.3.0
 Summary: Rendering HTML Text
 Home-page: https://github.com/bondbox/xhtm
 Author: Mingzhe Zou

{xhtm-0.2.0 → xhtm-0.3.0}/xhtm.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: xhtm
-Version: 0.2.0
+Version: 0.3.0
 Summary: Rendering HTML Text
 Home-page: https://github.com/bondbox/xhtm
 Author: Mingzhe Zou

{xhtm-0.2.0 → xhtm-0.3.0}/xhtm.egg-info/SOURCES.txt

@@ -26,4 +26,11 @@ xhtml/resource/__init__.py
 xhtml/resource/favicon.ico
 xhtml/resource/logo.svg
 xhtml/template/__init__.py
-xhtml/template/hello.html
+xhtml/template/hello.html
+xhtml/unittest/__init__.py
+xhtml/unittest/test_element.py
+xhtml/unittest/test_flask.py
+xhtml/unittest/test_header.py
+xhtml/unittest/test_request.py
+xhtml/unittest/test_resource.py
+xhtml/unittest/test_template.py

xhtm-0.3.0/xhtml/__init__.py

@@ -0,0 +1,11 @@
+# coding:utf-8
+
+from xhtml.element import *  # noqa:F401,F403
+from xhtml.flask import FlaskProxy  # noqa:F401
+from xhtml.header import AcceptLanguage  # noqa:F401
+from xhtml.header import LanguageQ  # noqa:F401
+from xhtml.request import StreamResponse  # noqa:F401
+from xhtml.resource import FileResource  # noqa:F401
+from xhtml.resource import Resource  # noqa:F401
+from xhtml.template import LocaleTemplate  # noqa:F401
+from xhtml.template import Template  # noqa:F401

{xhtm-0.2.0 → xhtm-0.3.0}/xhtml/attribute.py

@@ -3,7 +3,7 @@
 from urllib.parse import urljoin
 
 __project__ = "xhtm"
-__version__ = "0.2.0"
+__version__ = "0.3.0"
 __description__ = "Rendering HTML Text"
 __urlhome__ = "https://github.com/bondbox/xhtm"
 __urlcode__ = __urlhome__

xhtm-0.3.0/xhtml/element/__init__.py

@@ -0,0 +1,20 @@
+# coding:utf-8
+
+from xhtml.element.attr import Attr  # noqa:F401
+from xhtml.element.css import StyleCSS  # noqa:F401
+from xhtml.element.doc import HtmlDoc  # noqa:F401
+from xhtml.element.tag import Body  # noqa:F401
+from xhtml.element.tag import Br  # noqa:F401
+from xhtml.element.tag import Div  # noqa:F401
+from xhtml.element.tag import EmptyTag  # noqa:F401
+from xhtml.element.tag import Form  # noqa:F401
+from xhtml.element.tag import FormAttrs  # noqa:F401
+from xhtml.element.tag import Head  # noqa:F401
+from xhtml.element.tag import Html  # noqa:F401
+from xhtml.element.tag import HtmlAttrs  # noqa:F401
+from xhtml.element.tag import Input  # noqa:F401
+from xhtml.element.tag import InputAttrs  # noqa:F401
+from xhtml.element.tag import Span  # noqa:F401
+from xhtml.element.tag import Tag  # noqa:F401
+from xhtml.element.tag import TextTag  # noqa:F401
+from xhtml.element.tag import Title  # noqa:F401

{xhtm-0.2.0 → xhtm-0.3.0}/xhtml/element/css.py

@@ -1,8 +1,8 @@
 # coding:utf-8
 
-from .attr import Args
-from .attr import Arguments
-from .attr import Attr
+from xhtml.element.attr import Args
+from xhtml.element.attr import Arguments
+from xhtml.element.attr import Attr
 
 
 class StyleCSS(Attr):

{xhtm-0.2.0 → xhtm-0.3.0}/xhtml/element/doc.py

@@ -1,6 +1,6 @@
 # coding:utf-8
 
-from .tag import Html
+from xhtml.element.tag import Html
 
 
 class HtmlDoc(Html):
@@ -9,7 +9,7 @@ class HtmlDoc(Html):
         super().__init__()
 
     def __str__(self) -> str:
-        return f"<!DOCTYPE {self.__doctype}>\n{super().__str__()}"
+        return f"<!DOCTYPE {self.doctype}>\n{super().__str__()}"
 
     @property
     def doctype(self) -> str:

{xhtm-0.2.0 → xhtm-0.3.0}/xhtml/element/tag.py

@@ -6,12 +6,12 @@ from typing import List
 from typing import Optional
 from typing import TypeVar
 
-from ..attribute import __description__
-from ..attribute import __project__
-from .attr import Args
-from .attr import Arguments
-from .attr import Attr
-from .css import StyleCSS
+from xhtml.attribute import __description__
+from xhtml.attribute import __project__
+from xhtml.element.attr import Args
+from xhtml.element.attr import Arguments
+from xhtml.element.attr import Attr
+from xhtml.element.css import StyleCSS
 
 
 class Attrs(Args):

xhtm-0.3.0/xhtml/flask/__init__.py

@@ -0,0 +1,3 @@
+# coding:utf-8
+
+from xhtml.flask.proxy import FlaskProxy  # noqa:F401

xhtm-0.3.0/xhtml/header/__init__.py

@@ -0,0 +1,4 @@
+# coding:utf-8
+
+from xhtml.header.accept import AcceptLanguage  # noqa:F401
+from xhtml.header.accept import LanguageQ  # noqa:F401

xhtm-0.3.0/xhtml/request/__init__.py

@@ -0,0 +1,3 @@
+# coding:utf-8
+
+from xhtml.request.stream import StreamResponse  # noqa:F401

xhtm-0.3.0/xhtml/template/__init__.py

@@ -0,0 +1,32 @@
+# coding:utf-8
+
+from os.path import abspath
+from os.path import dirname
+from os.path import isdir
+from os.path import join
+from typing import Optional
+
+from xlc import Message
+from xlc import Section
+
+from xhtml.header import AcceptLanguage
+from xhtml.resource import Resource
+
+BASE_DIR = dirname(abspath(__file__))
+
+
+class Template(Resource):
+    FAVICON: str = "favicon.ico"
+
+    def __init__(self, base: Optional[str] = None):
+        super().__init__(base if base and isdir(base) else BASE_DIR)
+
+
+class LocaleTemplate(Template):
+    def __init__(self, base: str):
+        self.__message: Message = Message.load(join(base, "locale"))
+        super().__init__(base)
+
+    def search(self, accept_language: str, section: str) -> Section:
+        language: AcceptLanguage = AcceptLanguage(accept_language)
+        return language.choice(self.__message).seek(section)

xhtm-0.3.0/xhtml/unittest/test_element.py

@@ -0,0 +1,108 @@
+# coding:utf-8
+
+import unittest
+
+from xhtml.element.doc import HtmlDoc
+from xhtml.element.tag import Br
+from xhtml.element.tag import Div
+from xhtml.element.tag import Form
+from xhtml.element.tag import Input
+from xhtml.element.tag import Span
+
+
+class TestHtmlDoc(unittest.TestCase):
+
+    @classmethod
+    def setUpClass(cls):
+        cls.title: str = "Login"
+        cls.html: HtmlDoc = HtmlDoc()
+        cls.html.head.title.text = cls.title
+        cls.user: Input = Input({"type": "text", "name": "username", "placeholder": "Username"})  # noqa:E501
+        cls.user.attrs.std_style.width.v = "200px"
+        cls.user.attrs.std_style.height.v = "30px"
+        cls.word: Input = Input({"type": "password", "name": "password", "placeholder": "Password"})  # noqa:E501
+        cls.word.attrs.std_style.width.v = "200px"
+        cls.word.attrs.std_style.height.v = "30px"
+        cls.post: Input = Input({"type": "submit", "value": "Submit"})
+        cls.post.attrs.std_style.width.v = "200px"
+        cls.post.attrs.std_style.height.v = "30px"
+        cls.form: Form = Form({"method": "post"})
+        cls.form.add(Div(attrs={"style": "text-align: center;"}, child=[cls.user, Br()]))  # noqa: E501
+        cls.form.add(Span(attrs={"style": "display: block; margin-bottom: 10px;"}))  # noqa: E501
+        cls.form.add(Div(attrs={"style": "text-align: center;"}, child=[cls.word, Br()]))  # noqa: E501
+        cls.form.add(Span(attrs={"style": "display: block; margin-bottom: 20px;"}))  # noqa: E501
+        cls.form.add(Div(attrs={"style": "text-align: center;"}, child=[cls.post, Br()]))  # noqa: E501
+        cls.root: Div = Div()
+        cls.root.add(cls.form)
+        cls.root.attrs.std_style.height.v = "60vh"
+        cls.root.attrs.std_style.display.v = "grid"
+        cls.root.attrs.std_style.place_items.v = "center"
+        cls.html.body.add(cls.root)
+
+    @classmethod
+    def tearDownClass(cls):
+        pass
+
+    def setUp(self):
+        pass
+
+    def tearDown(self):
+        pass
+
+    def test_html(self):
+        self.assertIsInstance(str(self.html), str)
+
+    def test_std_attrs(self):
+        self.assertEqual(len(self.html.attrs), 0)
+        self.assertEqual(self.html.attrs.xmlns.v, "")
+        self.assertEqual(self.html.attrs.std_accesskey.v, "")
+        self.assertEqual(self.html.attrs.std_class.v, "")
+        self.assertEqual(self.html.attrs.std_contenteditable.v, "")
+        self.assertEqual(self.html.attrs.std_contextmenu.v, "")
+        self.assertEqual(self.html.attrs.std_dir.v, "")
+        self.assertEqual(self.html.attrs.std_draggable.v, "")
+        self.assertEqual(self.html.attrs.std_dropzone.v, "")
+        self.assertEqual(self.html.attrs.std_enterkeyhint.v, "")
+        self.assertEqual(self.html.attrs.std_hidden.v, "")
+        self.assertEqual(self.html.attrs.std_id.v, "")
+        self.assertEqual(self.html.attrs.std_inert.v, "")
+        self.assertEqual(self.html.attrs.std_inputmode.v, "")
+        self.assertEqual(self.html.attrs.std_lang.v, "")
+        self.assertEqual(self.html.attrs.std_popover.v, "")
+        self.assertEqual(self.html.attrs.std_spellcheck.v, "")
+        self.assertEqual(self.html.attrs.std_tabindex.v, "")
+        self.assertEqual(self.html.attrs.std_title.v, "")
+        self.assertEqual(self.html.attrs.std_translate.v, "")
+        self.assertNotIn("test", self.html.attrs)
+        self.html.attrs["test"] = "unit"
+        self.assertEqual(self.html.attrs["test"].v, "unit")
+        self.assertEqual(len(self.html.attrs), 20)
+        self.assertIsInstance(self.html.attrs.keys(), tuple)
+        self.assertIsInstance(self.html.attrs.values(), tuple)
+        self.assertIsInstance(self.html.attrs.items(), tuple)
+        self.assertNotIn("unit", self.html.attrs)
+        self.html.attrs.hit("unit", "test")
+        self.assertEqual(self.html.attrs["unit"].v, "test")
+        self.assertEqual(len(self.html.attrs), 21)
+
+    def test_css_style(self):
+        self.assertEqual(self.root.attrs.std_style.margin.v, "")
+        self.assertEqual(self.root.attrs.std_style.margin_top.v, "")
+        self.assertEqual(self.root.attrs.std_style.margin_bottom.v, "")
+        self.assertEqual(self.root.attrs.std_style.margin_left.v, "")
+        self.assertEqual(self.root.attrs.std_style.margin_right.v, "")
+        self.assertEqual(self.root.attrs.std_style.text_align.v, "")
+        self.assertEqual(self.root.attrs.std_style.vertical_align.v, "")
+
+    def test_form(self):
+        self.assertEqual(self.form.attrs.method.v, "post")
+
+    def test_input(self):
+        self.assertEqual(self.user.attrs.name.v, "username")
+        self.assertEqual(self.user.attrs.placeholder.v, "Username")
+        self.assertEqual(self.user.attrs.type.v, "text")
+        self.assertEqual(self.user.attrs.value.v, "")
+
+
+if __name__ == "__main__":
+    unittest.main()

xhtm-0.3.0/xhtml/unittest/test_flask.py

@@ -0,0 +1,78 @@
+# coding:utf-8
+
+import unittest
+from unittest.mock import MagicMock
+from unittest.mock import patch
+
+from flask import Request
+from werkzeug.test import EnvironBuilder
+
+from xhtml.flask import proxy
+
+
+class TestFlaskProxy(unittest.TestCase):
+
+    @classmethod
+    def setUpClass(cls):
+        cls.cookie = MagicMock()
+        cls.cookie.name = "test"
+        cls.cookie.value = "unittest"
+        cls.cookie.expires = 1000
+        cls.cookie.path = "/"
+        cls.cookie.domain = "example.com"
+        cls.cookie.secure = True
+
+    @classmethod
+    def tearDownClass(cls):
+        pass
+
+    def setUp(self):
+        self.proxy = proxy.FlaskProxy("http://example.com")
+
+    def tearDown(self):
+        pass
+
+    @patch.object(proxy.requests, "get")
+    @patch.object(proxy, "stream_with_context")
+    def test_request_get_success(self, mock_stream_with_context, mock_get):
+        fake_response = MagicMock()
+        fake_response.status_code = 200
+        fake_response.raw.headers = {"Content-Type": "text/html"}
+        fake_response.cookies = [self.cookie]
+        mock_get.return_value = fake_response
+        mock_stream_with_context.side_effect = ["unittest"]
+        request = Request(EnvironBuilder().get_environ())
+        response = self.proxy.request(request)
+        self.assertEqual(response.status_code, 200)
+        self.assertEqual(response.headers["Content-Type"], "text/html")
+
+    @patch.object(proxy.requests, "post")
+    @patch.object(proxy, "stream_with_context")
+    def test_request_post_success(self, mock_stream_with_context, mock_post):
+        fake_response = MagicMock()
+        fake_response.status_code = 201
+        fake_response.raw.headers = {"Content-Type": "application/json"}
+        fake_response.cookies = [self.cookie]
+        mock_post.return_value = fake_response
+        mock_stream_with_context.side_effect = ["unittest"]
+        request = Request(EnvironBuilder(method="post").get_environ())
+        response = self.proxy.request(request)
+        self.assertEqual(response.status_code, 201)
+        self.assertEqual(response.headers["Content-Type"], "application/json")
+
+    @patch.object(proxy.requests, "get")
+    def test_request_UnsupportedMethod(self, mock_get):
+        request = Request(EnvironBuilder(method="put").get_environ())
+        response = self.proxy.request(request)
+        self.assertEqual(response.status_code, 405)
+
+    @patch.object(proxy.requests, "get")
+    def test_request_ConnectionError(self, mock_get):
+        mock_get.side_effect = proxy.requests.ConnectionError
+        request = Request(EnvironBuilder().get_environ())
+        response = self.proxy.request(request)
+        self.assertEqual(response.status_code, 502)
+
+
+if __name__ == "__main__":
+    unittest.main()

xhtm-0.3.0/xhtml/unittest/test_header.py

@@ -0,0 +1,58 @@
+# coding:utf-8
+
+import unittest
+
+from xhtml.header.accept import AcceptLanguage
+from xhtml.header.accept import LanguageQ
+
+
+class TestLanguageQ(unittest.TestCase):
+
+    @classmethod
+    def setUpClass(cls):
+        cls.q: LanguageQ = LanguageQ("zh-CN,zh", 0.9)
+
+    @classmethod
+    def tearDownClass(cls):
+        pass
+
+    def setUp(self):
+        pass
+
+    def tearDown(self):
+        pass
+
+    def test_str(self):
+        self.assertEqual(str(self.q), "zh-CN,zh;q=0.9")
+
+    def test_len(self):
+        self.assertEqual(len(self.q), 2)
+
+
+class TestAcceptLanguage(unittest.TestCase):
+
+    @classmethod
+    def setUpClass(cls):
+        cls.lang: AcceptLanguage = AcceptLanguage("zh-CN,zh;q=0.9,en;q=0.8,en-GB;q=0.7,en-US;q=0.6")  # noqa:E501
+
+    @classmethod
+    def tearDownClass(cls):
+        pass
+
+    def setUp(self):
+        pass
+
+    def tearDown(self):
+        pass
+
+    def test_len_and_contains(self):
+        self.assertEqual(len(self.lang), 5)
+        self.assertNotIn("zh-TW", self.lang)
+        self.assertNotIn("zh-HK", self.lang)
+        self.assertIn("zh-CN", self.lang)
+        self.assertIn("zh", self.lang)
+        self.assertIn("en", self.lang)
+
+
+if __name__ == "__main__":
+    unittest.main()

xhtm-0.3.0/xhtml/unittest/test_request.py

@@ -0,0 +1,44 @@
+# coding:utf-8
+
+from typing import Generator
+import unittest
+from unittest.mock import MagicMock
+
+from xhtml.request import stream
+
+
+class TestStreamResponse(unittest.TestCase):
+
+    @classmethod
+    def setUpClass(cls):
+        cls.cookie = MagicMock()
+        cls.cookie.name = "test"
+        cls.cookie.value = "unittest"
+        cls.cookie.expires = 1000
+        cls.cookie.path = "/"
+        cls.cookie.domain = "example.com"
+        cls.cookie.secure = True
+
+    @classmethod
+    def tearDownClass(cls):
+        pass
+
+    def setUp(self):
+        fake_response = MagicMock()
+        fake_response.status_code = 200
+        fake_response.raw.headers = {"Content-Type": "text/html"}
+        fake_response.cookies = [self.cookie]
+        fake_response.iter_content.return_value = ["unittest", "unittest"]
+        self.stream = stream.StreamResponse(fake_response)
+
+    def tearDown(self):
+        pass
+
+    def test_generator(self):
+        self.assertIsInstance(self.stream.generator, Generator)
+        for chunk in self.stream.generator:
+            self.assertEqual(chunk, "unittest")
+
+
+if __name__ == "__main__":
+    unittest.main()

xhtm-0.3.0/xhtml/unittest/test_resource.py

@@ -0,0 +1,59 @@
+# coding:utf-8
+
+import unittest
+
+from xhtml.resource import FileResource
+from xhtml.resource import Resource
+
+
+class TestFileResource(unittest.TestCase):
+
+    @classmethod
+    def setUpClass(cls):
+        pass
+
+    @classmethod
+    def tearDownClass(cls):
+        pass
+
+    def setUp(self):
+        pass
+
+    def tearDown(self):
+        pass
+
+    def test_file_not_found(self):
+        self.assertRaises(FileNotFoundError, FileResource, "test.txt")
+
+
+class TestResource(unittest.TestCase):
+
+    @classmethod
+    def setUpClass(cls):
+        cls.res: Resource = Resource()
+
+    @classmethod
+    def tearDownClass(cls):
+        pass
+
+    def setUp(self):
+        pass
+
+    def tearDown(self):
+        pass
+
+    def test_favicon(self):
+        self.assertIsInstance(self.res.favicon.loadb(), bytes)
+
+    def test_favicon_ext(self):
+        self.assertEqual(self.res.favicon.ext, ".ico")
+
+    def test_seek(self):
+        self.assertIsInstance(self.res.seek("logo.svg").loads(), str)
+
+    def test_seek_file_not_found(self):
+        self.assertRaises(FileNotFoundError, self.res.seek, "test.txt")
+
+
+if __name__ == "__main__":
+    unittest.main()

xhtm-0.3.0/xhtml/unittest/test_template.py

@@ -0,0 +1,33 @@
+# coding:utf-8
+
+import os
+import unittest
+
+from xhtml.template import LocaleTemplate
+
+
+class TestLocaleTemplate(unittest.TestCase):
+
+    @classmethod
+    def setUpClass(cls):
+        cls.base: str = os.path.dirname(os.path.abspath(__file__))
+        cls.template: LocaleTemplate = LocaleTemplate(cls.base)
+
+    @classmethod
+    def tearDownClass(cls):
+        pass
+
+    def setUp(self):
+        pass
+
+    def tearDown(self):
+        pass
+
+    def test_search(self):
+        self.assertEqual(self.template.search("zh-CN,zh;q=0.9,en;q=0.8,en-GB;q=0.7,en-US;q=0.6", "login").lang.tag, "zh-Hans")  # noqa:E501
+        self.assertEqual(self.template.search("en", "login").lang.tag, "en")
+        self.assertEqual(self.template.search("fr", "login").lang.tag, "en")
+
+
+if __name__ == "__main__":
+    unittest.main()

xhtm-0.2.0/xhtml/__init__.py

@@ -1,10 +0,0 @@
-# coding:utf-8
-
-from .element import *  # noqa:F401,F403
-from .flask import FlaskProxy  # noqa:F401
-from .header import AcceptLanguage  # noqa:F401
-from .header import LanguageQ  # noqa:F401
-from .request import StreamResponse  # noqa:F401
-from .resource import FileResource  # noqa:F401
-from .resource import Resource  # noqa:F401
-from .template import Template  # noqa:F401

xhtm-0.2.0/xhtml/element/__init__.py

@@ -1,20 +0,0 @@
-# coding:utf-8
-
-from .attr import Attr  # noqa:F401
-from .css import StyleCSS  # noqa:F401
-from .doc import HtmlDoc  # noqa:F401
-from .tag import Body  # noqa:F401
-from .tag import Br  # noqa:F401
-from .tag import Div  # noqa:F401
-from .tag import EmptyTag  # noqa:F401
-from .tag import Form  # noqa:F401
-from .tag import FormAttrs  # noqa:F401
-from .tag import Head  # noqa:F401
-from .tag import Html  # noqa:F401
-from .tag import HtmlAttrs  # noqa:F401
-from .tag import Input  # noqa:F401
-from .tag import InputAttrs  # noqa:F401
-from .tag import Span  # noqa:F401
-from .tag import Tag  # noqa:F401
-from .tag import TextTag  # noqa:F401
-from .tag import Title  # noqa:F401

xhtm-0.2.0/xhtml/flask/__init__.py

@@ -1,3 +0,0 @@
-# coding:utf-8
-
-from .proxy import FlaskProxy  # noqa:F401

xhtm-0.2.0/xhtml/header/__init__.py

@@ -1,4 +0,0 @@
-# coding:utf-8
-
-from .accept import AcceptLanguage  # noqa:F401
-from .accept import LanguageQ  # noqa:F401

xhtm-0.2.0/xhtml/request/__init__.py

@@ -1,3 +0,0 @@
-# coding:utf-8
-
-from .stream import StreamResponse  # noqa:F401

xhtm-0.2.0/xhtml/template/__init__.py

@@ -1,17 +0,0 @@
-# coding:utf-8
-
-from os.path import abspath
-from os.path import dirname
-from os.path import isdir
-from typing import Optional
-
-from xhtml.resource import Resource
-
-BASE_DIR = dirname(abspath(__file__))
-
-
-class Template(Resource):
-    FAVICON: str = "favicon.ico"
-
-    def __init__(self, base: Optional[str] = None):
-        super().__init__(base if base and isdir(base) else BASE_DIR)