Initial commit

.env.example

@@ -0,0 +1,12 @@
+# PostgreSQL database connection information
+DATABASE_URL=
+
+# If set, protects the API from unauthorized called
+FASTAPI_API_KEY=
+
+# SMTP config
+SMTP_SERVER="smtp.gmail.com"
+SMTP_PORT=587
+SENDER_EMAIL=
+SENDER_PASSWORD=
+RECEIVER_EMAIL="jedha.fraud@yopmail.com"

migrations/version_0.sql

@@ -0,0 +1,38 @@
+-- Create table TRANSACTION
+CREATE TABLE IF NOT EXISTS TRANSACTIONS (
+    id SERIAL PRIMARY KEY,
+    transaction_number VARCHAR NOT NULL,
+    transaction_amount DECIMAL(10, 2) NOT NULL,
+    transaction_datetime TIMESTAMP NOT NULL,
+    transaction_category VARCHAR,
+    customer_firstname VARCHAR,
+    customer_lastname VARCHAR,
+    customer_gender VARCHAR,
+    customer_credit_card_num VARCHAR NOT NULL,
+    customer_address_street VARCHAR,
+    customer_address_city VARCHAR,
+    customer_address_state VARCHAR,
+    customer_address_zip VARCHAR,
+    customer_address_latitude DECIMAL(9, 6),
+    customer_address_longitude DECIMAL(9, 6),
+    customer_address_city_population INT,
+    customer_job VARCHAR,
+    customer_dob DATE,
+    merchant_name VARCHAR NOT NULL,
+    merchant_address_latitude DECIMAL(9, 6),
+    merchant_address_longitude DECIMAL(9, 6),
+    is_fraud BOOLEAN,
+    -- Add unique constraint on (transaction_num, transaction_datetime)
+    CONSTRAINT unique_transaction UNIQUE (transaction_number, transaction_datetime)
+);
+
+-- Add index on transaction_number
+CREATE INDEX idx_transaction_number ON TRANSACTIONS (transaction_number);
+-- Add index on transaction_datetime
+CREATE INDEX idx_transaction_datetime ON TRANSACTIONS (transaction_datetime);
+-- Add index on transaction_category
+CREATE INDEX idx_transaction_category ON TRANSACTIONS (transaction_category);
+-- Add index on transaction_amount
+CREATE INDEX idx_transaction_amount ON TRANSACTIONS (transaction_amount);
+-- Add index on is_fraud
+CREATE INDEX idx_is_fraud ON TRANSACTIONS (is_fraud);

migrations/version_1.sql

@@ -0,0 +1,14 @@
+CREATE TABLE IF NOT EXISTS FRAUD_DETAILS (
+    id SERIAL PRIMARY KEY,
+    fk_transaction_id INT NOT NULL,
+    FOREIGN KEY (fk_transaction_id) REFERENCES TRANSACTIONS(id),
+    fraud_score DECIMAL(5, 2) NOT NULL,
+    model_version VARCHAR(50) NOT NULL,
+    notification_sent BOOLEAN NOT NULL DEFAULT FALSE,
+    notification_recipients VARCHAR,
+    notification_datetime TIMESTAMP,
+);
+
+CREATE INDEX idx_fraud_score ON FRAUD_DETAILS (fraud_score);
+CREATE INDEX idx_model_version ON FRAUD_DETAILS (model_version);
+CREATE INDEX idx_notification_sent ON FRAUD_DETAILS (notification_sent);

requirements.txt

@@ -0,0 +1,7 @@
+python-dotenv
+fastapi
+sqlalchemy
+psycopg[binary]
+pytest
+appengine-python-standard>=1.0.0
+uvicorn

src/.gitignore

@@ -0,0 +1 @@
+.env

src/entity/__init__.py

@@ -0,0 +1,3 @@
+
+from sqlalchemy.orm import declarative_base
+Base = declarative_base()

src/entity/api/transaction_api.py

@@ -0,0 +1,98 @@
+from typing import Optional, Literal
+from pydantic import BaseModel, Field
+from datetime import datetime
+from src.entity.transaction import Transaction
+import logging
+
+# Set up logging
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+class TransactionApi(BaseModel):
+    """
+    TransactionApi is a class that represents a transaction.
+    """
+    transaction_number: str = Field(..., title="Transaction number", description="The ID of the transaction.")
+    transaction_timestamp: int = Field(..., title="Timestamp", description="The timestamp of the transaction.")
+    transaction_amount: float = Field(..., ge=0, title="Amount", description="The transaction amount.")
+    transaction_category: Optional[str] = Field(None, title="Product category", description="The category of product of the transaction.")
+    merchant_name: str = Field(..., title="Name", description="The name of the merchant.")
+    merchant_latitude: float = Field(..., title="Latitude", description="The latitude of the merchant.")
+    merchant_longitude: float = Field(..., title="Longitude", description="The longitude of the merchant.")
+    customer_credit_card_number: str = Field(..., title="Customer's credit card", description="The credit card number of the customer.")
+    customer_gender: Optional[Literal['M', 'F']] = Field(None, title="Customer's gender", description="The gender of the customer.")
+    customer_first_name: Optional[str] = Field(None, title="Customer's first name", description="The first name of the customer.")
+    customer_last_name: Optional[str] = Field(None, title="Customer's last name", description="The last name of the customer.")
+    customer_date_of_birth: Optional[str] = Field(None, title="Customer's date of birth", description="The date of birth of the customer.")
+    customer_job: Optional[str] = Field(None, title="Customer's job", description="The job of the customer.")
+    customer_street: Optional[str] = Field(None, title="Customer's street", description="The street of the customer.")
+    customer_city: Optional[str] = Field(None, title="Customer's city", description="The city of the customer.")
+    customer_state: Optional[str] = Field(None, title="Customer's state", description="The state of the customer.")
+    customer_postal_code: Optional[int] = Field(None, title="Customer's postal code", description="The postal code of the customer.")
+    customer_latitude: float = Field(..., title="Customer's latitude", description="The latitude of the customer.")
+    customer_longitude: float = Field(..., title="Customer's longitude", description="The longitude of the customer.")
+    customer_city_population: Optional[int] = Field(None, ge=0, title="Customer's city population", description="The population of the city.")
+
+    def is_valid(self) -> bool:
+        """
+        Check if the transaction is valid.
+        """
+        logger.debug("Validating transaction...")
+        now = datetime.now().replace(microsecond=0)
+        
+        # The transaction amount should be greater than 0
+        if self.transaction_amount < 0:
+            logger.error("Transaction amount is negative.")
+            return False
+        
+        # Validate the transaction timestamp
+        try:
+            # Unix timestamps may not be very precise, so we divide by 1000 to get seconds
+            dt_object = datetime.fromtimestamp(self.transaction_timestamp // 1000)
+            if dt_object > now:
+                logger.error(f"Transaction timestamp is in the future ({dt_object} > {now}).")
+                return False
+        except ValueError:
+            logger.error("Invalid transaction timestamp.")
+            return False
+        
+        # Validate the customer date of birth
+        # The customer should be 10 years old at least to possess a credit card
+        # If the customer date of birth is not provided, we assume the customer is older than 10
+        # If the customer date of birth is provided, we check if the customer is older than 10
+        if self.customer_date_of_birth:
+            try:
+                dob = datetime.strptime(self.customer_date_of_birth, "%Y-%m-%d")
+                age = (now - dob).days // 365
+                if age < 10:
+                    logger.error("Customer is younger than 10 years old.")
+                    return False
+            except ValueError:
+                logger.error("Invalid customer date of birth format. Expected YYYY-MM-DD.")
+                return False
+
+        return True
+    
+    def to_transaction(self) -> Transaction:
+        return Transaction(
+            transaction_number=self.transaction_number,
+            transaction_amount=self.transaction_amount,
+            transaction_datetime=datetime.fromtimestamp(self.transaction_timestamp / 1000),
+            transaction_category=self.transaction_category,
+            merchant_name=self.merchant_name,
+            merchant_address_latitude=self.merchant_latitude,
+            merchant_address_longitude=self.merchant_longitude,
+            customer_credit_card_number=self.customer_credit_card_number,
+            customer_gender=self.customer_gender,
+            customer_firstname=self.customer_first_name,
+            customer_lastname=self.customer_last_name,
+            customer_dob=self.customer_date_of_birth,
+            customer_job=self.customer_job,
+            customer_address_street=self.customer_street,
+            customer_address_city=self.customer_city,
+            customer_address_state=self.customer_state,
+            customer_address_zip=self.customer_postal_code,
+            customer_address_latitude=self.customer_latitude,
+            customer_address_longitude=self.customer_longitude,
+            customer_address_city_population=self.customer_city_population
+        )

src/entity/fraud_details.py

@@ -0,0 +1,18 @@
+from sqlalchemy import String, Float, Boolean, DateTime, ForeignKey
+from sqlalchemy.orm import relationship, mapped_column, Mapped
+
+from . import Base
+
+class FraudDetails(Base):
+    __tablename__ = "fraud_details"
+
+    # Transaction table columns
+    id: Mapped[int] = mapped_column(primary_key=True, autoincrement=True)
+    fraud_score: Mapped[float] = mapped_column(Float, nullable=True)
+    model_version: Mapped[str] = mapped_column(String(50), nullable=True)
+    notification_sent: Mapped[bool] = mapped_column(Boolean, nullable=False, default=False)
+    notification_recipients: Mapped[str] = mapped_column(String(255), nullable=True)
+    notification_datetime: Mapped[DateTime] = mapped_column(DateTime, nullable=True)
+
+    fk_transaction_id: Mapped[int] = mapped_column(ForeignKey("transactions.id"))
+    transaction: Mapped["Transaction"] = relationship("Transaction", back_populates="fraud_details")

src/entity/transaction.py

@@ -0,0 +1,39 @@
+
+from sqlalchemy import Integer, String, Float, Boolean, DateTime
+from sqlalchemy.orm import relationship, mapped_column, Mapped
+from src.entity.fraud_details import FraudDetails
+
+from . import Base
+
+class Transaction(Base):
+    """
+    Transaction table
+    """
+    __tablename__ = "transactions"
+
+    # Transaction table columns
+    id: Mapped[int] = mapped_column(primary_key=True)
+    transaction_number: Mapped[str] = mapped_column(String, nullable=False)
+    transaction_amount: Mapped[float] = mapped_column(Float, nullable=False)
+    transaction_datetime: Mapped[DateTime] = mapped_column(DateTime, nullable=False)
+    transaction_category: Mapped[str] = mapped_column(String, nullable=True)
+    customer_firstname: Mapped[str] = mapped_column(String, nullable=True)
+    customer_lastname: Mapped[str] = mapped_column(String, nullable=True)
+    customer_gender: Mapped[str] = mapped_column(String, nullable=True)
+    customer_credit_card_number: Mapped[str] = mapped_column('customer_credit_card_num', String, nullable=True)
+    customer_address_street: Mapped[str] = mapped_column(String, nullable=True)
+    customer_address_city: Mapped[str] = mapped_column(String, nullable=True)
+    customer_address_state: Mapped[str] = mapped_column(String, nullable=True)
+    customer_address_zip: Mapped[str] = mapped_column(String, nullable=True)
+    customer_address_latitude: Mapped[float] = mapped_column(Float, nullable=True)
+    customer_address_longitude: Mapped[float] = mapped_column(Float, nullable=True)
+    customer_address_city_population: Mapped[int] = mapped_column(Integer, nullable=True)
+    customer_job: Mapped[str] = mapped_column(String, nullable=True)
+    customer_dob: Mapped[DateTime] = mapped_column(DateTime, nullable=True)
+    merchant_name: Mapped[str] = mapped_column(String, nullable=True)
+    merchant_address_latitude: Mapped[float] = mapped_column(Float, nullable=True)
+    merchant_address_longitude: Mapped[float] = mapped_column(Float, nullable=True)
+    is_fraud: Mapped[bool] = mapped_column(Boolean, nullable=True)
+
+    # Dependent table
+    fraud_details: Mapped[FraudDetails] = relationship("FraudDetails", back_populates="transaction", cascade="all, delete-orphan", uselist=False)

src/main.py

@@ -0,0 +1,168 @@
+import os
+import logging
+import secrets
+from typing import Annotated
+from fastapi import (
+    FastAPI,
+    Request,
+    HTTPException,
+    Query,
+    Security,
+    Depends
+)
+from fastapi.background import BackgroundTasks
+from fastapi.responses import RedirectResponse
+from fastapi.security.api_key import APIKeyHeader
+from pydantic import BaseModel, Field
+from psycopg.errors import UniqueViolation, IntegrityError
+from starlette.status import (
+    HTTP_403_FORBIDDEN,
+    HTTP_422_UNPROCESSABLE_ENTITY,
+    HTTP_500_INTERNAL_SERVER_ERROR)
+from dotenv import load_dotenv
+from src.entity.api.transaction_api import TransactionApi
+from sqlalchemy.orm import Session
+
+from src.service.fraud_service import check_for_fraud
+from src.service.notification_service import send_notification
+from src.repository.common import get_session
+from src.repository.fraud_details_repo import insert_fraud
+from src.repository.transaction_repo import insert_transaction
+
+# ------------------------------------------------------------------------------
+
+load_dotenv()
+FASTAPI_API_KEY = os.getenv("FASTAPI_API_KEY")
+safe_clients = ['127.0.0.1']
+
+api_key_header = APIKeyHeader(name='Authorization', auto_error=False)
+
+async def validate_api_key(request: Request, key: str = Security(api_key_header)):
+    '''
+    Check if the API key is valid
+
+    Args:
+        key (str): The API key to check
+    
+    Raises:
+        HTTPException: If the API key is invalid
+    '''
+    if request.client.host not in safe_clients and not secrets.compare_digest(str(key), str(FASTAPI_API_KEY)):
+        raise HTTPException(
+            status_code=HTTP_403_FORBIDDEN, detail="Unauthorized - API Key is wrong"
+        )
+    return None
+
+app = FastAPI(dependencies=[Depends(validate_api_key)] if FASTAPI_API_KEY else None,
+              title="Fraud Detection Service API")
+
+
+# ------------------------------------------------------------------------------
+@app.get("/", include_in_schema=False)
+def redirect_to_docs():
+    '''
+    Redirect to the API documentation.
+    '''
+    return RedirectResponse(url='/docs')
+
+
+class TransactionProcessingOutput(BaseModel):
+    """
+    TransactionProcessingOutput is a class that represents the output of the transaction processing endpoint.
+    It contains the fraud detection result and the fraud score.
+    This class is used as the response model for the /transaction/process endpoint.
+    """
+    is_fraud: int = Field(description="The prediction result. 1 if the transaction is detected as fraudulent, 0 otherwise.", example=1)
+    fraud_score: float = Field(description="Probability of transaction being fraudulent.", example=0.85)
+
+@app.post("/transaction/process",
+          tags=["transaction"],
+          description="Process a transaction",
+          response_model=TransactionProcessingOutput,
+          )
+async def process_transaction(
+    background_tasks: BackgroundTasks,
+    transactionApi: Annotated[TransactionApi, Query()],
+    db: Annotated[Session, Depends(get_session)]
+):
+    """
+    Process a transaction
+    """
+    # Check the transaction
+    if not transactionApi.is_valid():
+        raise HTTPException(
+            status_code=HTTP_422_UNPROCESSABLE_ENTITY,
+            detail="Transaction is not valid. Check input values."
+        )
+    
+    # Convert the API object to a Transaction object
+    transaction = transactionApi.to_transaction()
+
+    # Process the transaction
+    try:
+        # Insert every single transaction into the database
+        transaction = insert_transaction(db, transaction)
+    except UniqueViolation as e:
+        logging.error(e)
+        raise HTTPException(
+            status_code=HTTP_422_UNPROCESSABLE_ENTITY,
+            detail=f"Transaction {transaction.transaction_number} already exists"
+        )
+    except IntegrityError as e:
+        logging.error(e)
+        raise HTTPException(
+            status_code=HTTP_422_UNPROCESSABLE_ENTITY,
+            detail=f"Transaction {transaction.transaction_number} is not valid. Check input values."
+        )
+    except Exception as e:
+        logging.error(e)
+        raise HTTPException(
+            status_code=HTTP_500_INTERNAL_SERVER_ERROR,
+            detail="An error occurred while processing the transaction. See logs for details."
+        )
+    
+    # Check for fraud
+    is_fraud = check_for_fraud(transaction)
+
+    if is_fraud:
+        insert_fraud(
+            db=db,
+            transaction=transaction,
+            fraud_score=0.5,
+            model_version='latest'
+        )
+
+        # Send notification to the user
+        background_tasks.add_task(
+            func=send_notification,
+            transaction_id=transaction.id)
+
+    # Return the result
+    output = {
+        'is_fraud': 1 if is_fraud else 0,
+        'fraud_score': 0.5 if is_fraud else 0.0
+    }
+
+    return output
+
+# ------------------------------------------------------------------------------
+@app.get("/check_health", tags=["general"], description="Check the health of the API")
+async def check_health(session: Annotated[Session, Depends(get_session)]):
+    """
+    Check all the services in the infrastructure are working
+    """
+    healthy = 0
+    unhealthy = 1
+
+    # DB check
+    db_status = False
+    try:
+        session.execute("SELECT 1")
+        db_status = True
+    except Exception:
+        pass
+
+    if db_status:
+        return healthy
+    else:
+        return unhealthy

src/repository/common.py

@@ -0,0 +1,22 @@
+from typing import Generator
+from sqlalchemy import create_engine
+from sqlalchemy.orm import sessionmaker
+
+from dotenv import load_dotenv
+import os
+
+load_dotenv()
+
+DATABASE_URL = os.getenv("DATABASE_URL")
+engine = create_engine(DATABASE_URL)
+SessionLocal = sessionmaker(bind=engine)
+
+def get_session() -> Generator:
+    """
+    Get a connection to the Postgres database
+    """
+    db = SessionLocal()
+    try:
+        yield db
+    finally:
+        db.close()

src/repository/fraud_details_repo.py

@@ -0,0 +1,27 @@
+from psycopg import Connection
+from typing import Optional
+from src.entity.fraud_details import FraudDetails
+from src.entity.transaction import Transaction
+
+def insert_fraud(db: Connection,
+                 transaction: Transaction,
+                 fraud_score: float,
+                 model_version: str) -> Optional[Transaction]:
+    """
+    Insert a fraud into the database
+    """
+    if transaction.fraud_details:
+        raise ValueError("Transaction already has fraud details")
+    
+    fraud = FraudDetails()
+    fraud.transaction = transaction
+    fraud.notification_sent = False
+    fraud.notification_recipients = None
+    fraud.notification_datetime = None
+    fraud.fraud_score = fraud_score
+    fraud.model_version = model_version
+    
+    db.add(fraud)
+    db.commit()
+    
+    return transaction

src/repository/transaction_repo.py

@@ -0,0 +1,39 @@
+import logging
+from psycopg import Connection
+from sqlalchemy.orm import joinedload
+
+from typing import Optional
+from src.entity.transaction import Transaction
+
+
+def fetch_transaction(db: Connection, transaction_id: int) -> Optional[Transaction]:
+    """
+    Fetch a transaction from the database
+    """
+    transaction = db.query(Transaction).options(
+        joinedload(Transaction.fraud_details)
+    ).filter(Transaction.id == transaction_id).first()
+    
+    if transaction is None:
+        raise ValueError(f"Transaction {transaction_id} not found")
+    else:
+        logging.info(f"Transaction {transaction_id} found")
+    
+    return transaction
+
+def commit_transaction(db: Connection, transaction: Transaction):
+    """
+    Commit a transaction to the database
+    """
+    db.merge(transaction)  # Make sure the object is in the session
+    db.commit()
+
+def insert_transaction(db: Connection, transaction: Transaction) -> Optional[Transaction]:
+    """
+    Insert a transaction into the database
+    """
+    db.add(transaction)
+    db.commit()
+    db.refresh(transaction)
+    
+    return transaction

src/service/fraud_service.py

@@ -0,0 +1,40 @@
+import logging
+from src.entity.transaction import Transaction
+
+# Configure logging
+logging.basicConfig(level=logging.DEBUG)
+logger = logging.getLogger(__name__)
+
+
+def check_for_fraud(transaction: Transaction) -> bool:
+    """
+    Check for fraud in the transaction.
+    """
+    logger.debug("Checking for fraud...")
+    
+    # Check if the transaction amount is greater than 1000
+    transaction_amount_threshold = 1000
+    if transaction.transaction_amount > transaction_amount_threshold:
+        logger.info(f"Transaction amount ({transaction.transaction_amount}) is greater than {transaction_amount_threshold}.")
+        return True
+    
+    # Check if the transaction category is 'electronics'
+    if transaction.transaction_category == 'electronics':
+        logger.info("Transaction category is electronics.")
+        return True
+    
+    # Check if the customer address city population is less than 1000
+    city_population_threshold = 1000
+    if transaction.customer_address_city_population < city_population_threshold:
+        logger.info(f"Customer address city population {transaction.customer_address_city_population} is less than {city_population_threshold}.")
+        return True
+    
+    # Check if the customer job is 'unemployed'
+    if transaction.customer_job == 'unemployed':
+        logger.info("Customer job is unemployed.")
+        return True
+    
+    # If none of the above conditions are met, return False
+    logger.debug("No fraud detected.")
+    
+    return False

src/service/notification_service.py

@@ -0,0 +1,90 @@
+import os
+import logging
+import smtplib
+from datetime import datetime
+from email.message import EmailMessage
+from src.repository.common import get_session
+from src.repository.transaction_repo import fetch_transaction
+
+from dotenv import load_dotenv
+
+# Configure logging
+logging.basicConfig(level=logging.DEBUG)
+logger = logging.getLogger(__name__)
+
+# Load environment variables
+load_dotenv()
+
+SMTP_SERVER = os.getenv("SMTP_SERVER")
+SMTP_PORT = os.getenv("SMTP_PORT")
+SENDER_EMAIL = os.getenv("SENDER_EMAIL")
+RECEIVER_EMAIL = os.getenv("RECEIVER_EMAIL")
+SENDER_PASSWORD = os.getenv("SENDER_PASSWORD")
+
+def send_notification(transaction_id: int):
+    """
+    Send a notification email when a transaction is detected as fraudulent.
+    """
+    logger.info("Sending notification email...")
+
+    # Fetch the transaction details from the database
+    with next(get_session()) as session:
+        transaction = fetch_transaction(session, transaction_id)
+        
+        if transaction is None:
+            logger.error(f"Transaction {transaction_id} not found")
+            return
+        if transaction.fraud_details.notification_sent:
+            logger.info(f"Notification already sent for transaction {transaction_id}")
+            return
+        
+        # Create the email
+        email_body = _build_notification_body(
+            transaction_number=transaction.transaction_number,
+            fraud_score=transaction.fraud_details.fraud_score,
+            model_version=transaction.fraud_details.model_version,
+        )
+
+        msg = EmailMessage()
+        msg["Subject"] = "Fraud detected!"
+        msg["From"] = SENDER_EMAIL
+        msg["To"] = RECEIVER_EMAIL
+        msg.set_content(email_body)
+
+        # Send the email
+        logging.debug(f"Connecting to SMTP server {SMTP_SERVER} using port {SMTP_PORT}...")
+        with smtplib.SMTP(SMTP_SERVER, SMTP_PORT) as server:
+            server.starttls()  # Secure the connection
+            server.login(SENDER_EMAIL, SENDER_PASSWORD)
+            server.send_message(msg)
+
+        logging.info("Email sent!")
+
+        # Update the transaction details in the database
+        transaction.fraud_details.notification_sent = True
+        transaction.fraud_details.notification_recipients = RECEIVER_EMAIL
+        transaction.fraud_details.notification_datetime = datetime.now()
+        session.commit()
+
+def _build_notification_body(
+        transaction_number: str,
+        fraud_score: float,
+        model_version: str,
+    ) -> str:
+    """
+    Build the body of the notification email.
+    """
+    logger.debug("Building notification email body...")
+    
+    # Create the email body
+    email_body = f"""
+    Fraud detected!
+    
+    Transaction number: {transaction_number}
+    Fraud score: {fraud_score}
+    Model version: {model_version}
+    
+    Please check the transaction.
+    """
+    
+    return email_body

tests/conftest.py

@@ -0,0 +1,79 @@
+import pytest
+import pandas as pd
+from src.entity.transaction import Transaction
+from src.entity.api.transaction_api import TransactionApi
+
+@pytest.fixture
+def valid_transaction():
+    return Transaction(
+        customer_address_city_population=333497,
+        customer_firstname='Jeff',
+        customer_lastname='Elliott',
+        customer_gender='M',
+        customer_job='Mechanical engineer',
+        customer_credit_card_number='2291163933867244',
+        customer_address_street='351 Darlene Green',
+        customer_address_city='Columbia',
+        customer_address_state='SC',
+        customer_address_zip='29209',
+        customer_address_latitude=33.9659,
+        customer_address_longitude=-80.9355,
+        customer_dob='1968-03-19',
+        transaction_number='2da90c7d74bd46a0caf3777415b3ebd3',
+        transaction_amount=2.86,
+        transaction_datetime=pd.to_datetime('2020-06-21 12:14:25'),
+        transaction_category='personal_care',
+        merchant_name='fraud_Kirlin and Sons',
+        merchant_address_latitude=33.986391,
+        merchant_address_longitude=-81.200714,
+    )
+
+@pytest.fixture
+def fraudulent_transaction():
+    return Transaction(
+        customer_address_city_population=23,
+        customer_firstname='Brooke',
+        customer_lastname='Smith',
+        customer_gender='F',
+        customer_job='Cytogeneticist',
+        customer_credit_card_number='3560725013359375',
+        customer_address_street='63542 Luna Brook Apt. 012',
+        customer_address_city='Notrees',
+        customer_address_state='TX',
+        customer_address_zip='79759',
+        customer_address_latitude=31.8599,
+        customer_address_longitude=-102.7413,
+        customer_dob='1969-09-15',
+        transaction_number='16bf2e46c54369a8eab2214649506425',
+        transaction_amount=2400000.84,
+        transaction_datetime=pd.to_datetime('2020-06-21 22:06:39'),
+        transaction_category='health_fitness',
+        merchant_name="fraud_Hamill-D'Amore",
+        merchant_address_latitude=32.575873,
+        merchant_address_longitude=-102.60429,
+    )
+
+@pytest.fixture
+def transaction_api():
+    return TransactionApi(
+        transaction_number="123456789",
+        transaction_timestamp=1633036800,
+        transaction_amount=100.0,
+        transaction_category="Electronics",
+        merchant_name="Best Buy",
+        merchant_latitude=37.7749,
+        merchant_longitude=-122.4194,
+        customer_credit_card_number="4111111111111111",
+        customer_gender="M",
+        customer_first_name="John",
+        customer_last_name="Doe",
+        customer_date_of_birth="1980-01-01",
+        customer_job="Engineer",
+        customer_street="123 Main St",
+        customer_city="San Francisco",
+        customer_state="CA",
+        customer_postal_code=94105,
+        customer_latitude=37.7749,
+        customer_longitude=-122.4194,
+        customer_city_population=870000,
+    )

tests/test_fraud_service.py

@@ -0,0 +1,19 @@
+from src.service.fraud_service import check_for_fraud
+from src.entity.transaction import Transaction
+
+def test_check_for_fraud_valid(valid_transaction: Transaction):
+    """
+    Test the method check_for_fraud
+    Case: valid transaction
+    """
+    is_fraud = check_for_fraud(valid_transaction)
+    assert is_fraud is False
+
+def test_check_for_fraud_invalid(fraudulent_transaction: Transaction):
+    """
+    Test the method check_for_fraud
+    Case: invalid transaction
+    """
+    is_fraud = check_for_fraud(fraudulent_transaction)
+    assert is_fraud is True
+

tests/test_notification_service.py

@@ -0,0 +1,15 @@
+from src.service.notification_service import _build_notification_body
+
+def test__build_notification_body():
+    """
+    Test the method _build_notification_body
+    """
+    email_body = _build_notification_body(
+        transaction_number="123456789",
+        fraud_score=0.95,
+        model_version="v1.0",
+    )
+
+    assert "123456789" in email_body
+    assert "0.95" in email_body
+    assert "v1.0" in email_body

tests/test_transaction_api_entity.py

@@ -0,0 +1,31 @@
+from src.entity.api.transaction_api import TransactionApi
+from datetime import datetime, timedelta
+
+def test_is_valid(transaction_api: TransactionApi):
+    """
+    Test the is_valid method of the TransactionApi class
+    Case: valid transaction_api object
+    """
+    # Check if the transaction_api object is valid
+    assert transaction_api.is_valid() is True
+
+def test_is_valid_negative_amount(transaction_api: TransactionApi):
+    # Check if the transaction_api object is invalid with negative amount
+    transaction_api.transaction_amount = -100.0
+    assert transaction_api.is_valid() is False
+
+def test_is_valid_future_timestamp(transaction_api: TransactionApi):
+    # Check if the transaction_api object is invalid with future timestamp
+    transaction_api.transaction_timestamp = 999999999999999
+    assert transaction_api.is_valid() is False
+
+def test_is_valid_future_dob(transaction_api: TransactionApi):
+    # Check if the transaction_api object is invalid with too young date of birth
+    nine_years_ago = datetime.now() - timedelta(days=365 * 9)  # 9 years old customer
+    transaction_api.customer_date_of_birth = nine_years_ago.strftime("%Y-%m-%d")
+    assert transaction_api.is_valid() is False
+
+def test_is_valid_invalid_date_format(transaction_api: TransactionApi):
+    # Check if the transaction_api object is invalid with invalid date of birth format
+    transaction_api.customer_date_of_birth = "01-01-1980"
+    assert transaction_api.is_valid() is False