Ensuring **meta tags** meet SEO guidelines is a common audit step for SEO specialists. You often need to verify that the **meta title** and **meta description** of a page fall within recommended character limits to maximize visibility and click-through rates. Automating this process with `Python` can save time and reduce manual errors.


import unittest
import user_code
import ast
import re   
import importlib
import csv
import unittest
import importlib

class TestTask(unittest.TestCase):
    def test_returns_dictionary_with_correct_keys(self):
        import user_code
        importlib.reload(user_code)
        html = """
        <html><head><title>Title for SEO Testing</title><meta name='description' content='This is a sample meta description for SEO compliance checking in Python.'></head></html>
        """
        result = user_code.check_meta_compliance(html)
        _dynamic_test(self,
            isinstance(result, dict) and "title" in result and "description" in result,
            "Returned dictionary contains 'title' and 'description' keys",
            f"Returned dictionary missing expected keys: {result}",
        )

    def test_inner_dict_has_length_and_compliant(self):
        import user_code
        importlib.reload(user_code)
        html = """
        <html><head><title>SEO Title Example</title><meta name='description' content='A meta description that is long enough to pass the SEO compliance check.'></head></html>
        """
        result = user_code.check_meta_compliance(html)
        for key in ["title", "description"]:
            inner = result.get(key)
            _dynamic_test(self,
                isinstance(inner, dict) and "length" in inner and "compliant" in inner,
                f"Returned inner dictionary for '{key}' contains 'length' and 'compliant'",
                f"Returned inner dictionary for '{key}' missing required keys: {inner}",
            )

    def test_title_length_and_compliance(self):
        import user_code
        importlib.reload(user_code)
        html = """
        <html><head><title>This title is exactly thirty characters!!</title></head></html>
        """
        result = user_code.check_meta_compliance(html)
        title_info = result.get("title")
        expected_length = len("This title is exactly thirty characters!!")
        _dynamic_test(self,
            title_info is not None and title_info["length"] == expected_length,
            "Title length matches extracted content",
            f"Expected title length {expected_length}, got {title_info}",
        )
        _dynamic_test(self,
            title_info is not None and title_info["compliant"] == (30 <= expected_length <= 60),
            "Title compliance correctly determined",
            f"Expected compliance {(30 <= expected_length <= 60)}, got {title_info}",
        )

    def test_description_length_and_compliance(self):
        import user_code
        importlib.reload(user_code)
        html = """
        <html><head><meta name="description" content="This is a meta description that is exactly seventy characters long for testing."></head></html>
        """
        result = user_code.check_meta_compliance(html)
        desc_info = result.get("description")
        expected_length = len("This is a meta description that is exactly seventy characters long for testing.")
        _dynamic_test(self,
            desc_info is not None and desc_info["length"] == expected_length,
            "Description length matches extracted content",
            f"Expected description length {expected_length}, got {desc_info}",
        )
        _dynamic_test(self,
            desc_info is not None and desc_info["compliant"] == (70 <= expected_length <= 160),
            "Description compliance correctly determined",
            f"Expected compliance {(70 <= expected_length <= 160)}, got {desc_info}",
        )

    def test_non_compliant_title_and_description(self):
        import user_code
        importlib.reload(user_code)
        html = """
        <html><head><title>Short</title><meta name="description" content="Too short."></head></html>
        """
        result = user_code.check_meta_compliance(html)
        title_info = result.get("title")
        desc_info = result.get("description")
        _dynamic_test(self,
            title_info is not None and title_info["compliant"] == False,
            "Title correctly marked as non-compliant when too short",
            f"Expected non-compliant title, got {title_info}",
        )
        _dynamic_test(self,
            desc_info is not None and desc_info["compliant"] == False,
            "Description correctly marked as non-compliant when too short",
            f"Expected non-compliant description, got {desc_info}",
        )

    def test_missing_tags(self):
        import user_code
        importlib.reload(user_code)
        html = "<html><head></head><body>No meta tags here.</body></html>"
        result = user_code.check_meta_compliance(html)
        title_info = result.get("title")
        desc_info = result.get("description")
        _dynamic_test(self,
            title_info is not None and title_info["length"] == 0 and title_info["compliant"] == False,
            "Missing title returns length 0 and non-compliant",
            f"Expected title length 0 and non-compliant, got {title_info}",
        )
        _dynamic_test(self,
            desc_info is not None and desc_info["length"] == 0 and desc_info["compliant"] == False,
            "Missing description returns length 0 and non-compliant",
            f"Expected description length 0 and non-compliant, got {desc_info}",
        )

    def test_uppercase_and_whitespace(self):
        import user_code
        importlib.reload(user_code)
        html = """
        <html><head>
        <TITLE>   This is a Title with Whitespace   </TITLE>
        <META NAME="DESCRIPTION" CONTENT="   This description has leading and trailing spaces.   ">
        </head></html>
        """
        result = user_code.check_meta_compliance(html)
        title_info = result.get("title")
        desc_info = result.get("description")
        expected_title = "This is a Title with Whitespace"
        expected_desc = "This description has leading and trailing spaces."
        _dynamic_test(self,
            title_info is not None and title_info["length"] == len(expected_title),
            "Title length trims whitespace correctly",
            f"Expected title length {len(expected_title)}, got {title_info}",
        )
        _dynamic_test(self,
            desc_info is not None and desc_info["length"] == len(expected_desc),
            "Description length trims whitespace correctly",
            f"Expected description length {len(expected_desc)}, got {desc_info}",
        )

def _dynamic_test(test_case, condition, success_message, failure_message):
    if condition:
        test_case._testMethodName = success_message
        test_case.assertTrue(True, success_message)
    else:
        test_case._testMethodName = failure_message
        test_case.fail(failure_message)

def normalize_text(text):
    text = text.lower()
    text = re.sub(r"\\s{2,}", " ", text)
    text = re.sub(r"\\s*([,:?])\\s*", r"\\1 ", text)
    return text.strip()

def change_var(code: str, var_name: str, value: str) -> str:
    tree = ast.parse(code)
    lines = code.splitlines()
    changed = False
    # Collect all assignment nodes to modify
    assign_nodes = [
        (i, node)
        for i, node in enumerate(tree.body)
        if isinstance(node, ast.Assign)
        and any(isinstance(target, ast.Name) and target.id == var_name for target in node.targets)
    ]

    # If nothing to change, return unmodified code
    if not assign_nodes:
        return code

    # Perform replacements for all matching assignments (from last to first to not break line offsets)
    for i, node in reversed(assign_nodes):
        start_line = node.lineno - 1
        line = lines[start_line]
        indent = ' ' * (len(line) - len(line.lstrip()))
        lines[start_line] = f"{indent}{var_name} = {value}"
        next_line = len(lines)
        for next_node in tree.body[i+1:]:
            if hasattr(next_node, 'lineno'):
                next_line = next_node.lineno - 1
                break
        if next_line > start_line + 1:
            lines[start_line+1:next_line] = []
        changed = True

    return '\\n'.join(lines) if changed else code

if __name__ == "__main__":
    unittest.main()


test_main.py

Master the use of Python to automate, analyze, and optimize SEO workflows. This course guides SEO professionals through practical Python applications for keyword research, on-page analysis, and technical SEO, using real-world scenarios and hands-on coding tasks.

Learn how Python can automate repetitive SEO tasks, from scraping search results to generating meta tags, making your SEO workflow more efficient.

Explore how Python can be used to analyze keyword data, identify opportunities, and visualize keyword trends for SEO campaigns.

Apply Python to analyze on-page SEO elements and perform technical audits, including content checks, tag analysis, and site structure evaluation.

Challenge: Meta Tag Compliance Checker

Solución