As a startup founder, automating the customer onboarding process can save you time, reduce manual errors, and help deliver a consistent experience to every new user. By using Python, you can efficiently process new customer data, generate personalized onboarding messages, and keep track of each customer's progress. Keeping an accurate record of onboarding status is crucial for monitoring engagement, following up with customers, and ensuring that no one falls through the cracks. This challenge puts your automation skills to the test and reinforces the importance of systematic customer tracking in startup operations.


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

class TestTask(unittest.TestCase):
    def setUp(self):
        self.user_code = importlib.import_module("user_code")
        importlib.reload(self.user_code)
        self.sample_customers = [
            {"name": "Alice Johnson", "email": "alice.johnson@example.com"},
            {"name": "Bob Smith", "email": "bob.smith@example.com"},
            {"name": "Charlie Lee", "email": "charlie.lee@example.com"},
        ]

    def test_generate_onboarding_message(self):
        fn = getattr(self.user_code, "generate_onboarding_message", None)
        _dynamic_test(
            self,
            callable(fn),
            "Function 'generate_onboarding_message' is defined",
            "Function 'generate_onboarding_message' is not defined",
        )
        name = "Alice Johnson"
        msg = fn(name)
        _dynamic_test(
            self,
            msg is not None and isinstance(msg, str) and name in msg,
            f"Message uses the customer's name ({name})",
            f"Expected name '{name}' in the onboarding message, got: '{msg}'",
        )

    def test_onboard_customers_returns_list(self):
        fn = getattr(self.user_code, "onboard_customers", None)
        _dynamic_test(
            self,
            callable(fn),
            "Function 'onboard_customers' is defined",
            "Function 'onboard_customers' is not defined",
        )
        result = fn(self.sample_customers)
        _dynamic_test(
            self,
            isinstance(result, list) and len(result) == 3,
            "Returned value is a list with 3 customer dictionaries",
            f"Expected list of length 3, got: {result}",
        )

    def test_customer_dict_keys(self):
        fn = getattr(self.user_code, "onboard_customers", None)
        result = fn(self.sample_customers)
        for idx, customer in enumerate(result):
            _dynamic_test(
                self,
                isinstance(customer, dict),
                f"Customer {idx+1} is a dictionary",
                f"Customer {idx+1} is not a dictionary: {customer}",
            )
            for key in ["name", "email", "onboarding_status", "message"]:
                _dynamic_test(
                    self,
                    key in customer,
                    f"Customer {idx+1} contains key '{key}'",
                    f"Customer {idx+1} missing key '{key}'",
                )

    def test_onboarding_status(self):
        fn = getattr(self.user_code, "onboard_customers", None)
        result = fn(self.sample_customers)
        for idx, customer in enumerate(result):
            status = customer.get("onboarding_status", None)
            _dynamic_test(
                self,
                status == "Onboarded",
                f"Customer {idx+1} onboarding status is 'Onboarded'",
                f"Customer {idx+1} onboarding status is not 'Onboarded': {status}",
            )

    def test_message_is_unique_and_personalized(self):
        fn = getattr(self.user_code, "onboard_customers", None)
        result = fn(self.sample_customers)
        names = [c["name"] for c in self.sample_customers]
        for idx, customer in enumerate(result):
            msg = customer.get("message", "")
            name = customer.get("name", "")
            _dynamic_test(
                self,
                name in msg and isinstance(msg, str),
                f"Customer {idx+1} message contains their name",
                f"Customer {idx+1} message does not contain their name: {msg}",
            )
            # Check uniqueness among all messages
        all_msgs = [c["message"] for c in result]
        _dynamic_test(
            self,
            len(set(all_msgs)) == len(all_msgs),
            "All onboarding messages are unique",
            f"Onboarding messages are not unique: {all_msgs}",
        )

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

A practical Python course tailored for startup founders, focusing on leveraging Python to solve real-world business problems, automate tasks, analyze data, and make data-driven decisions. Each section is packed with engaging theory and hands-on challenges inspired by startup scenarios.

Learn how Python can automate and streamline everyday startup operations, from handling customer data to tracking growth metrics.

Harness the power of Python for data analysis and visualization to make informed decisions that drive startup growth.

Apply Python to solve growth, marketing, and customer insight challenges faced by startup founders.

Challenge: Automate Customer Onboarding

解答