wazzup 0.0.1__tar.gz

wazzup-0.0.1/LICENCE

@@ -0,0 +1,19 @@
+Copyright (c) 2018 The Python Packaging Authority
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

wazzup-0.0.1/PKG-INFO

@@ -0,0 +1,18 @@
+Metadata-Version: 2.4
+Name: wazzup
+Version: 0.0.1
+Summary: A python package for sending messages using the official Whatsapp API
+Author-email: Rafael model <rafael.model@d7.dev>
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/7ws/wazzup
+Project-URL: Issues, https://github.com/7ws/wazzup/issues
+Classifier: Programming Language :: Python :: 3
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENCE
+Dynamic: license-file
+
+# WaZZup
+
+

wazzup-0.0.1/README.md

@@ -0,0 +1,3 @@
+# WaZZup
+
+

wazzup-0.0.1/pyproject.toml

@@ -0,0 +1,24 @@
+[tool.isort]
+skip = [".git", "migrations"]
+include_trailing_comma = true
+multi_line_output = 7
+
+[project]
+name = "wazzup"
+version = "0.0.1"
+authors = [
+  { name="Rafael model", email="rafael.model@d7.dev" },
+]
+description = "A python package for sending messages using the official Whatsapp API"
+readme = "README.md"
+requires-python = ">=3.9"
+classifiers = [
+    "Programming Language :: Python :: 3",
+    "Operating System :: OS Independent",
+]
+license = "MIT"
+license-files = ["LICEN[CS]E*"]
+
+[project.urls]
+Homepage = "https://github.com/7ws/wazzup"
+Issues = "https://github.com/7ws/wazzup/issues"

wazzup-0.0.1/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

wazzup-0.0.1/src/wazzup/__init__.py

@@ -0,0 +1,3 @@
+from .messaging import Messaging
+
+__all__ = ["Messaging"]

wazzup-0.0.1/src/wazzup/messaging.py

@@ -0,0 +1,66 @@
+from src.wazzup import models
+from src.wazzup.models.template_message import TemplateMessage
+
+from .whatsapp import WhatsAppDriver
+
+
+class Messaging:
+    def __init__(self, access_token, phone_number_id):
+        self.whatsapp_driver = WhatsAppDriver(access_token, phone_number_id)
+
+    def send_text_message(self, text_message: 'models.TextMessage'):
+        """
+        Send a text message using the WhatsApp API
+        """
+        response = self.whatsapp_driver.send_text_message(
+            text_message=text_message,
+        )
+
+        return response
+
+    def reply_message(
+        self,
+        text_message: models.TextMessage,
+        message_id,
+    ):
+        """
+        Reply to a message using the WhatsApp API
+        """
+        response = self.whatsapp_driver.reply_message(text_message, message_id)
+
+        return response
+
+    def react_to_message(
+        self,
+        message_reaction: models.MessageReaction,
+    ):
+        """
+        React to a message using the WhatsApp API
+        """
+        response = self.whatsapp_driver.react_to_message(message_reaction)
+
+        return response
+
+    def send_image_message(self, image_message: models.ImageMessage):
+        """
+        Send an image message using the WhatsApp API
+        """
+        response = self.whatsapp_driver.send_image_message(image_message)
+
+        return response
+
+    def send_location_message(self, location_message: models.LocationMessage):
+        response = self.whatsapp_driver.send_location_message(location_message)
+
+        return response
+
+    def send_template_message(self, template: TemplateMessage):
+        """
+        Send a template message using the WhatsApp API
+
+        :param recipient_phone_number: The phone number of the recipient.
+        :param template_name: The name of the template to be sent.
+        """
+        response = self.whatsapp_driver.send_template_message(template)
+
+        return response

wazzup-0.0.1/src/wazzup/models/__init__.py

@@ -0,0 +1,13 @@
+from .image_message import ImageMessage
+from .location_message import LocationMessage
+from .message_reaction import MessageReaction
+from .template_message import TemplateMessage
+from .text_message import TextMessage
+
+__all__ = [
+    "ImageMessage",
+    "LocationMessage",
+    "MessageReaction",
+    "TemplateMessage",
+    "TextMessage",
+]

wazzup-0.0.1/src/wazzup/models/image_message.py

@@ -0,0 +1,23 @@
+from dataclasses import dataclass
+
+
+@dataclass
+class ImageMessage:
+
+    to: str
+    image: dict[str, str]
+    messaging_product: str = "whatsapp"
+    recipient_type: str = "individual"
+    type: str = "image"
+
+    def __init__(self, id: str, to: str):
+        """
+        Args:
+            message_id: The ID of the message to react to.
+            emoji: The emoji to use for the image.
+            to: The recipient's phone number in the format 1234567890'.
+        """
+        self.to = to
+        self.image = {
+            "id": id,
+        }

wazzup-0.0.1/src/wazzup/models/location_message.py

@@ -0,0 +1,32 @@
+from dataclasses import dataclass
+
+
+@dataclass
+class LocationMessage:
+
+    to: str
+    location: dict[str, str]
+    messaging_product: str = "whatsapp"
+    type: str = "location"
+
+    def __init__(
+        self,
+        to: str,
+        longitude: str,
+        latitude: str,
+        name: str,
+        address: str,
+    ):
+        """
+        Args:
+            message_id: The ID of the message to react to.
+            emoji: The emoji to use for the image.
+            to: The recipient's phone number in the format 1234567890'.
+        """
+        self.to = to
+        self.location = {
+            'latitude': latitude,
+            'longitude': longitude,
+            'name': name,
+            'address': address,
+        }

wazzup-0.0.1/src/wazzup/models/message_reaction.py

@@ -0,0 +1,24 @@
+from dataclasses import dataclass
+
+
+@dataclass
+class MessageReaction:
+
+    to: str
+    reaction: dict[str, str]
+    messaging_product: str = "whatsapp"
+    recipient_type: str = "individual"
+    type: str = "reaction"
+
+    def __init__(self, message_id: str, emoji, to: str):
+        """
+        Args:
+            message_id: The ID of the message to react to.
+            emoji: The emoji to use for the reaction.
+            to: The recipient's phone number in the format 1234567890'.
+        """
+        self.to = to
+        self.reaction = {
+            "message_id": message_id,
+            "emoji": emoji,
+        }

wazzup-0.0.1/src/wazzup/models/template_componenets.py

@@ -0,0 +1,49 @@
+from dataclasses import asdict, dataclass
+
+
+@dataclass
+class ComponentHeader:
+    parameters: list[dict[str, str]]
+    type: str = 'header'
+
+    def __init__(self, parameters):
+        self.parameters = [asdict(parameter) for parameter in parameters]
+
+
+@dataclass
+class ComponentBody:
+    parameters: list[dict[str, str]]
+    type: str = 'body'
+
+    def __init__(self, parameters):
+        self.parameters = [asdict(parameter) for parameter in parameters]
+
+
+@dataclass
+class ComponentFooter:
+    parameters: list[dict[str, str]]
+    type: str = 'footer'
+
+    def __init__(self, parameters):
+        self.parameters = [asdict(parameter) for parameter in parameters]
+
+
+@dataclass
+class ComponentButton:
+    parameters: list[dict[str, str]]
+    sub_type: str = 'quick_reply'
+    index: str = '0'
+    type: str = 'button'
+
+    def __init__(self, parameters):
+        self.parameters = [asdict(parameter) for parameter in parameters]
+
+
+@dataclass
+class TemplateComponent:
+    type: str
+    parameters: list[dict[str, str]]
+
+    def __init__(self, type: str, parameters):
+        self.type = type
+        self.parameters = [asdict(parameter) for parameter in parameters]

wazzup-0.0.1/src/wazzup/models/template_message.py

@@ -0,0 +1,24 @@
+from dataclasses import asdict, dataclass
+
+from .template_componenets import TemplateComponent
+
+
+@dataclass
+class TemplateMessage:
+    to: str
+    template: dict[str, str]
+    messaging_product: str = "whatsapp"
+    type: str = "template"
+
+    def __init__(
+        self,
+        to: str,
+        template_name: str,
+        components: list[TemplateComponent],
+    ):
+        self.to = to
+        self.template = {
+            'name': template_name,
+            "language": {"code": "pt_BR"},
+            'components': [asdict(component) for component in components]
+        }

wazzup-0.0.1/src/wazzup/models/template_parameters.py

@@ -0,0 +1,39 @@
+from dataclasses import dataclass
+
+
+@dataclass
+class PayloadParameter:
+    payload: str
+    type: str = 'payload'
+
+    def __init__(self, payload: str):
+        self.payload = payload
+
+
+@dataclass
+class ImageParameter:
+    image: dict[str, str]
+    type: str = 'image'
+
+    def __init__(self, image_link: str):
+        self.image = {'link': image_link}
+
+
+@dataclass
+class TextParameter:
+    text: dict[str, str]
+    type: str = 'text'
+
+    def __init__(self, text_content: str):
+        self.text = text_content
+
+
+@dataclass
+class NamedTextParameter:
+    parameter_name: str
+    text: str
+    type: str = 'text'
+
+    def __init__(self, parameter_name: str, value: str):
+        self.parameter_name = parameter_name
+        self.text = value

wazzup-0.0.1/src/wazzup/models/text_message.py

@@ -0,0 +1,32 @@
+from dataclasses import dataclass
+
+
+@dataclass
+class TextMessage:
+    """
+    Represents a text message in the WhatsApp application
+
+    Attributes:
+        sender (str): The sender of the message.
+        recipient (str): The recipient of the message.
+        content (str): The content of the message.
+        timestamp (str): The time when the message was sent.
+    """
+
+    to: str
+    text: dict[str, str]
+    messaging_product: str = "whatsapp"
+    recipient_type: str = "individual"
+    type: str = "text"
+
+    def __init__(self, message_content: str, to: str):
+        """
+        Args:
+            message_content: The content of the message.
+            to: The recipient of the message.
+        """
+        self.to = to
+        self.text = {
+            'preview_url': False,
+            'body': message_content
+        }

wazzup-0.0.1/src/wazzup/whatsapp.py

@@ -0,0 +1,117 @@
+from dataclasses import asdict
+from urllib.parse import urljoin
+
+import requests
+
+from src.wazzup import models
+
+
+class WhatsAppDriver:
+    BASE_URL = "https://graph.facebook.com/v22.0/"
+    RESOURCE_PATH = "{phone_number}/messages"
+
+    def __init__(self, access_token, phone_number_id):
+        self.access_token = access_token
+        self.url = urljoin(
+            self.BASE_URL,
+            self.RESOURCE_PATH.format(phone_number=phone_number_id),
+        )
+
+    def _get_common_headers(self) -> dict[str, str]:
+        """
+        Get standard headers for json response
+        """
+        headers = {
+            "Accept": "application/json",
+            "Content-Type": "application/json",
+            "Authorization": f"Bearer {self.access_token}",
+        }
+
+        return headers
+
+    def _make_request(
+        self,
+        method: str,
+        url: str,
+        data: dict[str, str],
+    ) -> None:
+        """
+        Perform requests to PagBank API endpoints
+        """
+        headers = self._get_common_headers()
+        response = requests.request(method, url, json=data, headers=headers)
+        response.raise_for_status()
+        return response
+
+    def send_text_message(self, text_message: models.TextMessage):
+        payload = asdict(text_message)
+
+        response = self._make_request(
+            method="POST",
+            url=self.url,
+            data=payload,
+        )
+
+        return response
+
+    def reply_message(
+        self,
+        text_message: models.TextMessage,
+        message_id,
+    ):
+        payload = asdict(text_message)
+        payload["context"] = {"message_id": message_id}
+
+        response = self._make_request(
+            method="POST",
+            url=self.url,
+            data=payload,
+        )
+
+        return response
+
+    def react_to_message(
+        self,
+        message_reactoin: models.MessageReaction,
+    ):
+        payload = asdict(message_reactoin)
+        response = self._make_request(
+            method="POST",
+            url=self.url,
+            data=payload,
+        )
+
+        return response
+
+    def send_image_message(self, image_message: models.ImageMessage):
+        payload = asdict(image_message)
+
+        response = self._make_request(
+            method="POST",
+            url=self.url,
+            data=payload,
+        )
+
+        return response
+
+    def send_location_message(self, location_message: models.LocationMessage):
+        payload = asdict(location_message)
+
+        response = self._make_request(
+            method="POST",
+            url=self.url,
+            data=payload,
+        )
+
+        return response
+
+    def send_template_message(self, template: models.TemplateMessage):
+        payload = asdict(template)
+
+        response = self._make_request(
+            method="POST",
+            url=self.url,
+            data=payload,
+        )
+
+        return response

wazzup-0.0.1/src/wazzup.egg-info/PKG-INFO

@@ -0,0 +1,18 @@
+Metadata-Version: 2.4
+Name: wazzup
+Version: 0.0.1
+Summary: A python package for sending messages using the official Whatsapp API
+Author-email: Rafael model <rafael.model@d7.dev>
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/7ws/wazzup
+Project-URL: Issues, https://github.com/7ws/wazzup/issues
+Classifier: Programming Language :: Python :: 3
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENCE
+Dynamic: license-file
+
+# WaZZup
+
+

wazzup-0.0.1/src/wazzup.egg-info/SOURCES.txt

@@ -0,0 +1,22 @@
+LICENCE
+README.md
+pyproject.toml
+src/wazzup/__init__.py
+src/wazzup/messaging.py
+src/wazzup/whatsapp.py
+src/wazzup.egg-info/PKG-INFO
+src/wazzup.egg-info/SOURCES.txt
+src/wazzup.egg-info/dependency_links.txt
+src/wazzup.egg-info/top_level.txt
+src/wazzup/models/__init__.py
+src/wazzup/models/image_message.py
+src/wazzup/models/location_message.py
+src/wazzup/models/message_reaction.py
+src/wazzup/models/template_componenets.py
+src/wazzup/models/template_message.py
+src/wazzup/models/template_parameters.py
+src/wazzup/models/text_message.py
+tests/test_internal.py
+tests/test_send_message.py
+tests/test_send_template_message.py
+tests/test_template_models.py

wazzup-0.0.1/src/wazzup.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

wazzup-0.0.1/src/wazzup.egg-info/top_level.txt

@@ -0,0 +1,2 @@
+misc
+wazzup

wazzup-0.0.1/tests/test_internal.py

@@ -0,0 +1,39 @@
+from src.wazzup import models
+from src.wazzup.messaging import Messaging
+from src.wazzup.models import template_componenets, template_parameters
+
+
+class _Test_send_text_message:
+    def test_xuxa(self):
+        access_token = 'EAAan7AMfBDUBO7FmdB0p7cGLh28GD1SeZBgE4PCQT3RwNIqpbPYvAFDDp2EUwdBH2LugAb9ZCWW9iRVBTV4HfKetL2Pm4h9bs5sK1eP0mnbpQem3rPsxQPcT2TI7ZBghsZCWu9OQE8egCSqPtqZATJdz9mPlc63f9NqxKquLLnwfIjEwDfLkY8gnO4WyZAFTUIuR6DoSPHN7SEkdaVvyeUrmfrNAXrlfVap3wX'
+        phone_number_id = '544908905382751'
+        recipient_phone_number = '5545999229802'
+
+        template_message = models.TemplateMessage(
+            to=recipient_phone_number,
+            template_name='lembrete_para_rafael',
+            components=[
+                template_componenets.ComponentHeader(
+                    parameters=[
+                        template_parameters.NamedTextParameter(
+                            parameter_name='user_name',
+                            value='Rafael'
+                        )
+                    ]
+                ),
+                template_componenets.ComponentBody(
+                    parameters=[
+                        template_parameters.NamedTextParameter(
+                            parameter_name='rider_name',
+                            value='Joana'
+                        )
+                    ]
+                )
+            ]
+        )
+
+        messaging = Messaging(access_token, phone_number_id)
+
+        response = messaging.send_template_message(template_message)
+
+        assert response.status_code == 200, response.data

wazzup-0.0.1/tests/test_send_message.py

@@ -0,0 +1,245 @@
+from src.wazzup import models
+from src.wazzup.messaging import Messaging
+
+
+class Test_send_text_message:
+    def test_calls_whatsapp_with_expected_data(self, mocker, requests_mock):
+        # Prepare
+        # Setup requests mock
+        requests_mock.request.return_value.status_code = 200
+
+        access_token = 'my_access_token'
+        phone_number_id = '1111111111111111'
+        recipient_phone_number = '222222222222222'
+        message_content = 'Hello, this is a test message!'
+        messaging = Messaging(access_token, phone_number_id)
+
+        text_message = models.TextMessage(
+            message_content=message_content,
+            to=recipient_phone_number,
+        )
+
+        # Call
+        response = messaging.send_text_message(text_message=text_message)
+
+        # Assert Response
+        assert response.status_code == 200, response.json()
+
+        # Assert Request
+        assert requests_mock.request.call_args_list == [
+            mocker.call(
+                'POST',
+                f'https://graph.facebook.com/v22.0/{phone_number_id}/messages',
+                json={
+                    'messaging_product': 'whatsapp',
+                    'recipient_type': 'individual',
+                    'to': f'{recipient_phone_number}',
+                    'type': 'text',
+                    'text': {
+                        'preview_url': False,
+                        'body': f'{message_content}',
+                    },
+                },
+                headers={
+                    'Accept': 'application/json',
+                    'Content-Type': 'application/json',
+                    'Authorization': f'Bearer {access_token}'},
+            )
+        ]
+
+
+class Test_reply_message:
+    def test_calls_whatsapp_with_expected_data(self, mocker, requests_mock):
+        # Prepare
+        # Setup requests mock
+        requests_mock.request.return_value.status_code = 200
+
+        access_token = 'my_access_token'
+        phone_number_id = 'phone_number_id'
+        recipient_phone_number = 'recipent_phone_number'
+        message_content = 'Hello, this is a test message!'
+        message_id = 'message_id'
+        messaging = Messaging(access_token, phone_number_id)
+
+        text_message = models.TextMessage(
+            message_content=message_content,
+            to=recipient_phone_number,
+        )
+
+        # Call
+        response = messaging.reply_message(text_message, message_id)
+
+        # Assert Response
+        assert response.status_code == 200, response.json()
+
+        # Assert Request
+        assert requests_mock.request.call_args_list == [
+            mocker.call(
+                'POST',
+                f'https://graph.facebook.com/v22.0/{phone_number_id}/messages',
+                json={
+                    'messaging_product': 'whatsapp',
+                    'recipient_type': 'individual',
+                    'to': f'{recipient_phone_number}',
+                    'type': 'text',
+                    'text': {
+                        'preview_url': False,
+                        'body': f'{message_content}',
+                    },
+                    'context': {
+                        'message_id': message_id,
+                    },
+                },
+                headers={
+                    'Accept': 'application/json',
+                    'Content-Type': 'application/json',
+                    'Authorization': f'Bearer {access_token}'},
+            )
+        ]
+
+
+class Test_react_to_message:
+    def test_calls_whatsapp_with_expected_data(self, mocker, requests_mock):
+        # Prepare
+        # Setup requests mock
+        requests_mock.request.return_value.status_code = 200
+
+        access_token = 'my_access_token'
+        phone_number_id = '1111111111111111'
+        recipient_phone_number = '222222222222222'
+        message_id = 'message_id'
+        emoji = '👍'
+        messaging = Messaging(access_token, phone_number_id)
+
+        text_message = models.MessageReaction(
+            message_id=message_id,
+            emoji=emoji,
+            to=recipient_phone_number,
+        )
+
+        # Call
+        response = messaging.react_to_message(text_message)
+
+        # Assert Response
+        assert response.status_code == 200, response.json()
+
+        # Assert Request
+        assert requests_mock.request.call_args_list == [
+            mocker.call(
+                'POST',
+                f'https://graph.facebook.com/v22.0/{phone_number_id}/messages',
+                json={
+                    'messaging_product': 'whatsapp',
+                    'recipient_type': 'individual',
+                    'to': f'{recipient_phone_number}',
+                    'type': 'reaction',
+                    'reaction': {
+                        'message_id': message_id,
+                        'emoji': emoji,
+                    },
+                },
+                headers={
+                    'Accept': 'application/json',
+                    'Content-Type': 'application/json',
+                    'Authorization': f'Bearer {access_token}'},
+            )
+        ]
+
+
+class Test_send_image_message:
+    def test_calls_whatsapp_with_expected_data(self, mocker, requests_mock):
+        # Prepare
+        # Setup requests mock
+        requests_mock.request.return_value.status_code = 200
+
+        access_token = 'my_access_token'
+        phone_number_id = '1111111111111111'
+        recipient_phone_number = '222222222222222'
+        image_id = 'image_id'
+        messaging = Messaging(access_token, phone_number_id)
+
+        image_message = models.ImageMessage(
+            id=image_id,
+            to=recipient_phone_number,
+        )
+
+        # Call
+        response = messaging.send_image_message(image_message=image_message)
+
+        # Assert Response
+        assert response.status_code == 200, response.json()
+
+        # Assert Request
+        assert requests_mock.request.call_args_list == [
+            mocker.call(
+                'POST',
+                f'https://graph.facebook.com/v22.0/{phone_number_id}/messages',
+                json={
+                    'messaging_product': 'whatsapp',
+                    'recipient_type': 'individual',
+                    'to': f'{recipient_phone_number}',
+                    'type': 'image',
+                    'image': {
+                        'id': f'{image_id}',
+                    },
+                },
+                headers={
+                    'Accept': 'application/json',
+                    'Content-Type': 'application/json',
+                    'Authorization': f'Bearer {access_token}'},
+            )
+        ]
+
+
+class Test_send_location_message:
+    def test_calls_whatsapp_with_expected_data(self, mocker, requests_mock):
+        # Prepare
+        # Setup requests mock
+        requests_mock.request.return_value.status_code = 200
+
+        access_token = 'my_access_token'
+        phone_number_id = '1111111111111111'
+        recipient_phone_number = '222222222222222'
+        latitude = '123'
+        longitude = '456'
+        name = 'Casa da Xuxa'
+        address = 'Rua no fim do arcoiris'
+        messaging = Messaging(access_token, phone_number_id)
+
+        location_message = models.LocationMessage(
+            to=recipient_phone_number,
+            latitude=latitude,
+            longitude=longitude,
+            name=name,
+            address=address,
+        )
+
+        # Call
+        response = messaging.send_location_message(location_message)
+
+        # Assert Response
+        assert response.status_code == 200, response.json()
+
+        # Assert Request
+        assert requests_mock.request.call_args_list == [
+            mocker.call(
+                'POST',
+                f'https://graph.facebook.com/v22.0/{phone_number_id}/messages',
+                json={
+                    'messaging_product': 'whatsapp',
+                    'to': f'{recipient_phone_number}',
+                    'type': 'location',
+                    'location': {
+                        'latitude': latitude,
+                        'longitude': longitude,
+                        'name': name,
+                        'address': address,
+                    },
+                },
+                headers={
+                    'Accept': 'application/json',
+                    'Content-Type': 'application/json',
+                    'Authorization': f'Bearer {access_token}'},
+            )
+        ]
+

wazzup-0.0.1/tests/test_send_template_message.py

@@ -0,0 +1,273 @@
+from src.wazzup import models
+from src.wazzup.messaging import Messaging
+from src.wazzup.models import template_componenets, template_parameters
+
+
+class Test_send_template_with_header_message:
+
+    def test_calls_whatsapp_with_expected_data(self, mocker, requests_mock):
+        # Prepare
+        # Setup requests mock
+        requests_mock.request.return_value.status_code = 200
+
+        access_token = 'my_access_token'
+        phone_number_id = '1111111111111111'
+        recipient_phone_number = '222222222222222'
+        template_mame = 'my_template_name'
+        messaging = Messaging(access_token, phone_number_id)
+
+        template_message = models.TemplateMessage(
+            to=recipient_phone_number,
+            template_name=template_mame,
+            components=[
+                template_componenets.ComponentHeader(
+                    parameters=[
+                        template_parameters.NamedTextParameter(
+                            parameter_name='my_parameter_name',
+                            value='My Header Text'
+                        )
+                    ]
+                )
+            ]
+        )
+
+        # Call
+        response = messaging.send_template_message(template_message)
+
+        # Assert Response
+        assert response.status_code == 200, response.json()
+
+        # Assert Request
+        assert requests_mock.request.call_args_list == [
+            mocker.call(
+                'POST',
+                f'https://graph.facebook.com/v22.0/{phone_number_id}/messages',
+                json={
+                    'messaging_product': 'whatsapp',
+                    'to': f'{recipient_phone_number}',
+                    'type': 'template',
+                    'template': {
+                        'name': f'{template_mame}',
+                        'language': {'code': 'pt_BR'},
+                        'components': [
+                            {
+                                'type': 'header',
+                                'parameters': [
+                                    {
+                                        'type': 'text',
+                                        'parameter_name': 'my_parameter_name',
+                                        'text': 'My Header Text'
+                                    }
+                                ]
+                            }
+                        ]
+                    },
+                },
+                headers={
+                    'Accept': 'application/json',
+                    'Content-Type': 'application/json',
+                    'Authorization': f'Bearer {access_token}'},
+            )
+        ]
+
+
+class Test_send_template_with_body_message:
+
+    def test_calls_whatsapp_with_expected_data(self, mocker, requests_mock):
+        # Prepare
+        # Setup requests mock
+        requests_mock.request.return_value.status_code = 200
+
+        access_token = 'my_access_token'
+        phone_number_id = '1111111111111111'
+        recipient_phone_number = '222222222222222'
+        template_mame = 'my_template_name'
+        messaging = Messaging(access_token, phone_number_id)
+
+        template_message = models.TemplateMessage(
+            to=recipient_phone_number,
+            template_name=template_mame,
+            components=[
+                template_componenets.ComponentBody(
+                    parameters=[
+                        template_parameters.NamedTextParameter(
+                            parameter_name='my_parameter_name',
+                            value='My Header Text'
+                        )
+                    ]
+                )
+            ]
+        )
+
+        # Call
+        response = messaging.send_template_message(template_message)
+
+        # Assert Response
+        assert response.status_code == 200, response.json()
+
+        # Assert Request
+        assert requests_mock.request.call_args_list == [
+            mocker.call(
+                'POST',
+                f'https://graph.facebook.com/v22.0/{phone_number_id}/messages',
+                json={
+                    'messaging_product': 'whatsapp',
+                    'to': f'{recipient_phone_number}',
+                    'type': 'template',
+                    'template': {
+                        'name': f'{template_mame}',
+                        'language': {'code': 'pt_BR'},
+                        'components': [
+                            {
+                                'type': 'body',
+                                'parameters': [
+                                    {
+                                        'type': 'text',
+                                        'parameter_name': 'my_parameter_name',
+                                        'text': 'My Header Text'
+                                    }
+                                ]
+                            }
+                        ]
+                    },
+                },
+                headers={
+                    'Accept': 'application/json',
+                    'Content-Type': 'application/json',
+                    'Authorization': f'Bearer {access_token}'},
+            )
+        ]
+
+
+class Test_send_template_with_footer_message:
+
+    def test_calls_whatsapp_with_expected_data(self, mocker, requests_mock):
+        # Prepare
+        # Setup requests mock
+        requests_mock.request.return_value.status_code = 200
+
+        access_token = 'my_access_token'
+        phone_number_id = '1111111111111111'
+        recipient_phone_number = '222222222222222'
+        template_mame = 'my_template_name'
+        messaging = Messaging(access_token, phone_number_id)
+
+        template_message = models.TemplateMessage(
+            to=recipient_phone_number,
+            template_name=template_mame,
+            components=[
+                template_componenets.ComponentFooter(
+                    parameters=[
+                        template_parameters.NamedTextParameter(
+                            parameter_name='my_parameter_name',
+                            value='My Header Text'
+                        )
+                    ]
+                )
+            ]
+        )
+
+        # Call
+        response = messaging.send_template_message(template_message)
+
+        # Assert Response
+        assert response.status_code == 200, response.json()
+
+        # Assert Request
+        assert requests_mock.request.call_args_list == [
+            mocker.call(
+                'POST',
+                f'https://graph.facebook.com/v22.0/{phone_number_id}/messages',
+                json={
+                    'messaging_product': 'whatsapp',
+                    'to': f'{recipient_phone_number}',
+                    'type': 'template',
+                    'template': {
+                        'name': f'{template_mame}',
+                        'language': {'code': 'pt_BR'},
+                        'components': [
+                            {
+                                'type': 'footer',
+                                'parameters': [
+                                    {
+                                        'type': 'text',
+                                        'parameter_name': 'my_parameter_name',
+                                        'text': 'My Header Text'
+                                    }
+                                ]
+                            }
+                        ]
+                    },
+                },
+                headers={
+                    'Accept': 'application/json',
+                    'Content-Type': 'application/json',
+                    'Authorization': f'Bearer {access_token}'},
+            )
+        ]
+
+
+class Test_send_template_with_button_message:
+
+    def test_calls_whatsapp_with_expected_data(self, mocker, requests_mock):
+        # Prepare
+        # Setup requests mock
+        requests_mock.request.return_value.status_code = 200
+
+        access_token = 'my_access_token'
+        phone_number_id = '1111111111111111'
+        recipient_phone_number = '222222222222222'
+        template_mame = 'my_template_name'
+        messaging = Messaging(access_token, phone_number_id)
+
+        template_message = models.TemplateMessage(
+            to=recipient_phone_number,
+            template_name=template_mame,
+            components=[
+                template_componenets.ComponentButton(
+                    parameters=[
+                        template_parameters.PayloadParameter('My Payload Text')
+                    ]
+                )
+            ]
+        )
+
+        # Call
+        response = messaging.send_template_message(template_message)
+
+        # Assert Response
+        assert response.status_code == 200, response.json()
+
+        # Assert Request
+        assert requests_mock.request.call_args_list == [
+            mocker.call(
+                'POST',
+                f'https://graph.facebook.com/v22.0/{phone_number_id}/messages',
+                json={
+                    'messaging_product': 'whatsapp',
+                    'to': f'{recipient_phone_number}',
+                    'type': 'template',
+                    'template': {
+                        'name': f'{template_mame}',
+                        'language': {'code': 'pt_BR'},
+                        'components': [
+                            {
+                                "type": "button",
+                                "sub_type": "quick_reply",
+                                "index": "0",
+                                "parameters": [
+                                    {
+                                        "type": "payload",
+                                        "payload": "My Payload Text",
+                                    },
+                                ],
+                            }
+                        ],
+                    },
+                },
+                headers={
+                    'Accept': 'application/json',
+                    'Content-Type': 'application/json',
+                    'Authorization': f'Bearer {access_token}'},
+            )
+        ]

wazzup-0.0.1/tests/test_template_models.py

@@ -0,0 +1,132 @@
+from dataclasses import asdict
+
+from src.wazzup.models import template_componenets, template_parameters
+
+
+class Test_header_template_models:
+    def test_with_image_component(self):
+        # Prepare
+        header = template_componenets.ComponentHeader(
+            parameters=[
+                template_parameters.ImageParameter('image_link')
+            ]
+        )
+
+        # Call
+        dict_header = asdict(header)
+
+        # Assert
+        assert dict_header == {
+            "type": "header",
+            "parameters": [
+                {
+                    "type": "image",
+                    "image": {
+                        "link": "image_link"
+                    },
+                },
+            ],
+        }
+
+    def test_with_text_component(self):
+        # Prepare
+        header = template_componenets.ComponentHeader(
+            parameters=[
+                template_parameters.TextParameter('my text')
+            ]
+        )
+
+        # Call
+        dict_header = asdict(header)
+
+        # Assert
+        assert dict_header == {
+            "type": "header",
+            "parameters": [
+                {
+                    "type": "text",
+                    "text": 'my text'
+                },
+            ],
+        }
+
+
+class Test_body_template_models:
+    def test_with_text_and_image_component(self):
+        # Prepare
+        body = template_componenets.ComponentBody(
+            parameters=[
+                template_parameters.TextParameter('my text'),
+                template_parameters.ImageParameter('image_link'),
+            ]
+        )
+
+        # Call
+        dict_body = asdict(body)
+
+        # Assert
+        assert dict_body == {
+            "type": "body",
+            "parameters": [
+                {
+                    "type": "text",
+                    "text": 'my text'
+                },
+                {
+                    "type": "image",
+                    "image": {
+                        "link": "image_link"
+                    },
+                },
+            ],
+        }
+
+
+class Test_footer_template_models:
+    def test_with_text_component(self):
+        # Prepare
+        footer = template_componenets.ComponentFooter(
+            parameters=[
+                template_parameters.TextParameter('my text'),
+            ]
+        )
+
+        # Call
+        dict_footer = asdict(footer)
+
+        # Assert
+        assert dict_footer == {
+            "type": "footer",
+            "parameters": [
+                {
+                    "type": "text",
+                    "text": 'my text'
+                },
+            ],
+        }
+
+
+class Test_button_template_models:
+    def test_with_payload_component(self):
+        # Prepare
+        payload = template_componenets.ComponentButton(
+            parameters=[
+                template_parameters.PayloadParameter('my payload'),
+            ]
+        )
+
+        # Call
+        dict_payload = asdict(payload)
+
+        # Assert
+        assert dict_payload == {
+            "type": "button",
+            "sub_type": "quick_reply",
+            "index": "0",
+            "parameters": [
+                {
+                    "type": "payload",
+                    "payload": "my payload",
+                },
+            ],
+        }