diff --git a/.github/workflows/python-tests.yml b/.github/workflows/python-tests.yml
new file mode 100644
index 0000000..93f0dd8
--- /dev/null
+++ b/.github/workflows/python-tests.yml
@@ -0,0 +1,21 @@
+name: Python Tests
+
+on: [push, pull_request]
+
+jobs:
+  test:
+    runs-on: ubuntu-latest
+
+    steps:
+      - uses: actions/checkout@v3
+
+      - name: Set up Python
+        uses: actions/setup-python@v4
+
+      - name: Install dependencies
+        run: |
+          python -m pip install --upgrade pip
+          pip install -r requirements.txt
+
+      - name: Run tests
+        run: python -m unittest discover -s test
diff --git a/.gitignore b/.gitignore
new file mode 100644
index 0000000..ed8ebf5
--- /dev/null
+++ b/.gitignore
@@ -0,0 +1 @@
+__pycache__
\ No newline at end of file
diff --git a/README.md b/README.md
index 936c906..ba32399 100644
--- a/README.md
+++ b/README.md
@@ -3,9 +3,7 @@
 The name is pretty self explanatory. It's a Python script for updating type A DNS records at one.com.
 
 ## Required Packages
-- `requests`
-- `json`
-- `sys`
+Check requirements.txt
 
 ## Usage
 At the very top of the Script there are some customization options and variables for your one.com control panel login credentials.
diff --git a/dockerfile b/dockerfile
new file mode 100644
index 0000000..1ffaddd
--- /dev/null
+++ b/dockerfile
@@ -0,0 +1,18 @@
+FROM python:3-alpine AS base
+FROM base AS builder
+
+RUN mkdir /install
+WORKDIR /install
+COPY requirements.txt /requirements.txt
+RUN pip install --no-binary=:all: --target=/install -r /requirements.txt
+
+FROM base
+COPY --from=builder /install /usr/local
+
+WORKDIR /app
+
+COPY . .
+RUN pip3 install -r requirements.txt
+
+ENTRYPOINT ["python3", "one_com_ddns.py"]
+CMD []
\ No newline at end of file
diff --git a/modules/dns_utils.py b/modules/dns_utils.py
new file mode 100644
index 0000000..3de27f8
--- /dev/null
+++ b/modules/dns_utils.py
@@ -0,0 +1,69 @@
+# modules/dns_utils.py
+import dns.resolver
+import dns.exception
+import logging
+
+logger = logging.getLogger("one_com_ddns")
+
+def get_authoritative_ns(domain):
+    """
+    Recursively finds the authoritative nameservers for a given domain.
+    Tries parent domains if no NS records are found or in case of timeout or other DNS errors
+    (except for NXDOMAIN, where it stops and indicates domain does not exist).
+
+    Args:
+        domain (str): The domain to query.
+
+    Returns:
+        list: A list of authoritative nameserver hostnames, or None if not found or domain does not exist.
+    """
+    try:
+        answers = dns.resolver.resolve(domain, 'NS')
+        return [data.to_text() for data in answers]
+    except dns.resolver.NoAnswer:
+        exception_type = "NoAnswer"
+    except dns.exception.Timeout:
+        exception_type = "Timeout"
+    except dns.resolver.NXDOMAIN:
+        exception_type = "NXDOMAIN"
+    except dns.exception.DNSException as e:
+        exception_type = f"DNSException: {e}"
+
+    # Handle exceptions that might indicate trying parent domain
+    if exception_type in ["NoAnswer", "Timeout", "DNSException", "NXDOMAIN"]:
+        parts = domain.split('.')
+        if len(parts) > 2:  # Check if there's a parent domain
+            parent_domain = '.'.join(parts[1:])
+            return get_authoritative_ns(parent_domain)
+        else:
+            logger.warning(f"No authoritative NS for {domain} and no parent domain to try after exception: {exception_type}")
+            return None  # No parent domain, give up
+    else: # Should not reach here, but as a fallback. For completeness.
+        logger.error(f"Failed to get NS for {domain} due to: {exception_type}")
+        return None
+
+def get_ip_and_ttl(domain, ns_servers=None):
+    """
+    Gets the IP address and TTL of a domain from the authoritative nameservers.
+
+    Args:
+        domain (str): The domain to query.
+        optional ns_servers (list): A list of authoritative nameserver hostnames.
+
+    Returns:
+        tuple: A tuple containing the IP address and TTL, or None if not found.
+    """
+    if ns_servers is None:
+        ns_servers = get_authoritative_ns(domain)
+        if ns_servers is None:
+            return None
+    resolver = dns.resolver.Resolver()
+    tmp = [dns.resolver.resolve(ns, 'A')[0].address for ns in ns_servers]
+    resolver.nameservers = tmp
+    try:
+        answers = resolver.resolve(domain, 'A')
+        for rdata in answers:
+            return rdata.address, answers.ttl
+    except (dns.resolver.NoAnswer, dns.resolver.NXDOMAIN, dns.exception.Timeout, dns.exception.DNSException) as e:
+        logger.warning(f"Error getting IP and TTL for {domain}: {e}")
+        return None
\ No newline at end of file
diff --git a/modules/logger.py b/modules/logger.py
new file mode 100644
index 0000000..1c3a21c
--- /dev/null
+++ b/modules/logger.py
@@ -0,0 +1,35 @@
+# modules/logger.py
+import logging
+
+GRAY = '\033[90m'
+RED = '\033[91m'
+YELLOW = '\033[93m'
+RESET = '\033[0m'
+
+class ColoredFormatter(logging.Formatter):
+    """A formatter that adds colors based on log level."""
+
+    def format(self, record):
+        log_level = record.levelname
+        if log_level == "DEBUG":
+            log_level_colored = f"{GRAY}[DEBUG]{RESET}"
+        elif log_level == "WARNING":
+            log_level_colored = f"{YELLOW}[WARN]{RESET}"
+        elif log_level == "ERROR":
+            log_level_colored = f"{RED}[ERROR]{RESET}"
+        else:
+            log_level_colored = f"[{log_level}]"  # No color for INFO
+
+        return logging.Formatter(f'{log_level_colored} %(message)s').format(record)
+
+def setup_logging(level=logging.INFO):
+    """Sets up centralized logging for the application."""
+    formatter = ColoredFormatter()
+    handler = logging.StreamHandler()
+    handler.setFormatter(formatter)
+
+    logger = logging.getLogger("one_com_ddns")
+    logger.setLevel(level)
+    logger.addHandler(handler)
+
+    return logger
\ No newline at end of file
diff --git a/modules/one_com_api.py b/modules/one_com_api.py
new file mode 100644
index 0000000..0e29674
--- /dev/null
+++ b/modules/one_com_api.py
@@ -0,0 +1,99 @@
+# modules/one_com_api.py
+import requests
+import json
+import tldextract
+import logging
+
+logger = logging.getLogger("one_com_ddns")
+
+def _find_between(haystack, needle1, needle2):
+    index1 = haystack.find(needle1) + len(needle1)
+    index2 = haystack.find(needle2, index1 + 1)
+    return haystack[index1 : index2]
+
+def login_session(username, password):
+    logger.info("Logging in...")
+    session = requests.session()
+    redirect_url = "https://www.one.com/admin/"
+    try:
+        r = session.get(redirect_url)
+    except requests.ConnectionError:
+        logger.error("Connection to one.com failed.")
+        raise SystemExit("Connection to one.com failed.")
+
+    post_url = _find_between(r.text, '<form id="kc-form-login" class="Login-form login autofill" onsubmit="login.disabled = true; return true;" action="', '"').replace('&amp;', '&')
+    login_data = {'username': username, 'password': password, 'credentialId': ''}
+    response = session.post(post_url, data=login_data)
+    if "Invalid username or password." in response.text:
+        logger.error("Invalid credentials. Exiting")
+        exit(1)
+    logger.info("Login successful.")
+    return session
+
+def select_admin_domain(session, domain):
+    request_str = f"https://www.one.com/admin/select-admin-domain.do?domain={domain}"
+    session.get(request_str)
+
+def get_custom_records(session, domain):
+    extracted = tldextract.extract(domain)
+    primary_domain = f"{extracted.domain}.{extracted.suffix}"
+    logger.info(f"Getting Records for primary domain: {primary_domain} (Requesting for: {domain})")
+    dns_url = f"https://www.one.com/admin/api/domains/{primary_domain}/dns/custom_records"
+    try:
+        response = session.get(dns_url)
+        response.raise_for_status()
+        get_res = response.text
+        if not get_res:
+            raise ValueError("Empty response from API")
+        data = json.loads(get_res)
+        records = data["result"]["data"]
+        # Validate that the records are in the expected list format.
+        if not isinstance(records, list):
+            raise TypeError("DNS records are not in the expected list format")
+        return records
+    except requests.exceptions.RequestException as e:
+        logger.error(f"Error fetching DNS records for domain: {domain}. HTTP Status Code: {e.response.status_code if e.response else 'N/A'}")
+        raise SystemExit(f"Failed to get DNS records for domain {domain}: {e}") from e
+    except (json.JSONDecodeError, KeyError, TypeError, ValueError) as e:
+        logger.error(f"Error parsing JSON response for domain: {domain}. Response text was: {get_res}")
+        raise SystemExit(f"Failed to parse DNS records JSON for domain {domain}: {e}") from e
+
+
+def find_id_by_subdomain(records, subdomain):
+    extracted_subdomain = tldextract.extract(subdomain).subdomain
+    logger.info(f"searching domain prefix for: '{extracted_subdomain}'")
+    for obj in records:
+        if obj["attributes"]["prefix"] == extracted_subdomain:
+            logger.info(f"Found Domain Prefix '{extracted_subdomain}': {obj['id']}")
+            return obj
+    return None
+
+def change_ip(session, record, domain, ip, ttl):
+    record_id = record["id"]
+    current_ttl = record["attributes"]["ttl"]
+    actual_ttl = ttl if ttl is not None else current_ttl
+    extracted = tldextract.extract(domain)
+    primary_domain = f"{extracted.domain}.{extracted.suffix}"
+    subdomain = extracted.subdomain
+    logger.info(f"Changing IP on record for subdomain '{subdomain}' - ID '{record_id}' TO NEW IP '{ip}' with TTL '{actual_ttl}' on primary domain '{primary_domain}'")
+    to_send = {
+        "type": "dns_service_records",
+        "id": record_id,
+        "attributes": {
+            "type": "A",
+            "prefix": subdomain,
+            "content": ip,
+            "ttl": actual_ttl
+        }
+    }
+    dns_url = f"https://www.one.com/admin/api/domains/{primary_domain}/dns/custom_records/{record_id}"
+    send_headers = {'Content-Type': 'application/json'}
+    try:
+        response = session.patch(dns_url, data=json.dumps(to_send), headers=send_headers)
+        response.raise_for_status()
+        logger.info("Sent Change IP Request")
+    except requests.exceptions.RequestException as e:
+        logger.error(f"Error updating IP for record with subdomain '{subdomain}': {e}")
+        status_code = e.response.status_code if e.response else 'N/A'
+        logger.error(f"HTTP Status Code: {status_code}")
+        raise SystemExit(f"Failed to update IP for record with subdomain {subdomain}: {e}") from e
\ No newline at end of file
diff --git a/modules/one_com_config.py b/modules/one_com_config.py
new file mode 100644
index 0000000..afaf4f4
--- /dev/null
+++ b/modules/one_com_config.py
@@ -0,0 +1,74 @@
+# modules/one_com_config.py
+import os
+import argparse
+import requests
+import logging
+
+logger = logging.getLogger("one_com_ddns")
+
+def parse_config(validate_required=True):
+    """
+    Parses configuration for the one.com DDNS script from command-line arguments,
+    environment variables, and returns None as default if no value is set.
+
+    Configuration is prioritized: command-line arguments > environment variables > None (if unset).
+
+    Key configuration parameters:
+        - username (-u, --username): one.com username (defaults to None if unset)
+        - password (-p, --password): one.com password (defaults to None if unset)
+        - domains (-d, --domains): List of domain names (e.g.,-d example.com example2.com) (defaults to None if unset)
+        - ip (-i, --ip): IP address source ('AUTO', 'ARG', or IP) (defaults to None if unset)
+        - force-update (-f, --force-update): Force DNS update (defaults to None if unset)
+        - ttl (-t, --ttl): TTL for DNS records (defaults to None if unset)
+        - skip-confirmation (--skip-confirmation): Skip confirmation prompts (defaults to False if unset)
+
+    Returns:
+        argparse.Namespace: Object containing configuration parameters.
+
+    Raises:
+        ValueError: If validate_required is True and username, password, or domain are None
+                    after parsing.
+        SystemExit: If automatic IP retrieval fails when 'AUTO' is selected
+                    or if no IP address is provided as a command-line argument
+                    when 'ARG' is selected.
+    """
+    parser = argparse.ArgumentParser(description="one.com DDNS Script Configuration")
+
+    parser.add_argument("-u", "--username", help="one.com username", default=os.environ.get("USERNAME"))
+    parser.add_argument("-p", "--password", help="one.com password", default=os.environ.get("PASSWORD"))
+    env_domains = os.environ.get("DOMAINS")
+    if env_domains is not None:
+        env_domains = env_domains.split(',')
+
+    parser.add_argument("-d", "--domains", nargs="+", help="List of domain names (e.g.,-d example.com example2.com)", default=env_domains)
+    parser.add_argument("-i", "--ip", help="IP address ('AUTO', or IP)", default=os.environ.get("IP", "AUTO"))
+
+    env_force = os.environ.get("FORCE_DNS_UPDATE")
+    if env_force is not None:
+        env_force = env_force.lower()
+
+    parser.add_argument("-f", "--force-update", action="store_true", help="Force DNS update (skip IP check)", default=env_force)
+    parser.add_argument("-t", "--ttl", type=int, help="TTL value for DNS records", default=os.environ.get("TTL"))
+    parser.add_argument("-y", "--skip-confirmation", action="store_true", help="Skip confirmation prompts", default=os.environ.get("SKIP_CONFIRMATION"))
+
+    args = parser.parse_args()
+
+    # Basic validation (ONLY IF validate_required is True)
+    if validate_required:
+        if not args.username:
+            raise ValueError("Username is required (command-line or USERNAME env var)")
+        if not args.password:
+            raise ValueError("Password is required (command-line or PASSWORD env var)")
+        if not args.domains:
+            raise ValueError("Domain is required (command-line or DOMAIN env var)")
+
+    # Handle IP address retrieval
+    if args.ip == "AUTO":
+        try:
+            args.ip = requests.get("https://api.ipify.org/").text
+        except requests.ConnectionError:
+            logger.error("Failed to get IP Address from ipify")
+            raise SystemExit("Failed to get IP Address from ipify")
+        logger.info(f"Detected external IP: {args.ip}")
+
+    return args
\ No newline at end of file
diff --git a/modules/update_utils.py b/modules/update_utils.py
new file mode 100644
index 0000000..9efb4b4
--- /dev/null
+++ b/modules/update_utils.py
@@ -0,0 +1,35 @@
+# modules/update_utils.py
+import sys
+import modules.one_com_api as one_com_api
+import logging
+
+logger = logging.getLogger("one_com_ddns")
+
+def _confirm_proceed(prompt: str) -> bool:
+    """
+    Prompt for confirmation unless running in a non-interactive shell.
+    """
+    if not sys.stdin.isatty():
+        logger.info("Non-interactive shell detected; proceeding without user confirmation.")
+        return True
+    response = input(prompt)
+    return response.strip().lower() == 'y'
+
+def update_domain(s, domain, records, ip, ttl, current_dns_ip=None, skip_confirmation=False):
+    """
+    Updates the DNS record for a given domain, handling confirmation and logging.
+    """
+    record_obj = one_com_api.find_id_by_subdomain(records, domain)
+    if record_obj is None:
+        logger.error(f"Record '{domain}' could not be found.")
+        return
+
+    if current_dns_ip:
+        logger.warning(f"Changing IP for {domain} from {current_dns_ip} to {ip} with TTL {ttl}.")
+    else:
+        logger.info(f"Changing IP for {domain} to {ip} with TTL {ttl}.")
+
+    if skip_confirmation or _confirm_proceed("Do you want to proceed? (y/n): "):
+        one_com_api.change_ip(s, record_obj, domain, ip, ttl)
+    else:
+        logger.info(f"Update for {domain} cancelled.")
diff --git a/one_com_ddns.py b/one_com_ddns.py
index e273c92..8b136b3 100644
--- a/one_com_ddns.py
+++ b/one_com_ddns.py
@@ -1,13 +1,12 @@
 '''
-
     #################################
-    ##                             ##
-    ##     one.com DDNS Script     ##
-    ##                             ##
+    ##                               ##
+    ##    one.com DDNS Script        ##
+    ##                               ##
     #################################
-    | Version      | 2.4            |
+    | Version       | 2.4             |
     +--------------+----------------+
-    | Last Updated | 2023-10-05     |
+    | Last Updated | 2023-10-05       |
     +--------------+----------------+
 
     +----------------+-------------------------+
@@ -17,8 +16,6 @@
     +----------------+-------------------------+
 
 
-
-
     Note:
         This script is not very fail proof.
         Very few possible exceptions are handled, something as simple
@@ -27,168 +24,67 @@
 
         If you have any problems or suggestions, please open an issue
         on github or send me an email (main@lugico.de)
-
 '''
 
+import modules.dns_utils as dns_utils
+import modules.one_com_config as config
+import modules.one_com_api as one_com_api
+import modules.logger as logger_module
+import modules.update_utils as update_utils
 
+logger = logger_module.setup_logging()  # Setup logging
 
-# YOUR ONE.COM LOGIN
-USERNAME="email.address@example.com"
-PASSWORD="Your Beautiful Password"
-
-# YOUR DOMAIN ( NOT www.example.com, only example.com )"
-DOMAIN="example.com"
-
-# LIST OF SUBDOMAINS YOU WANT POINTING TO YOUR IP
-SUBDOMAINS = ["myddns"]
-# SUBDOMAINS = ["mutiple", "subdomains"]
-
-
-# YOUR IP ADDRESS.
-IP='AUTO'
-# '127.0.0.1' -> IP  Address
-# 'AUTO'      -> Automatically detect using ipify.org
-# 'ARG'       -> Read from commandline argument ($ python3 ddns.py 127.0.0.1)
-
-
-# CHECK IF IP ADDRESS HAS CHANGED SINCE LAST SCRIPT EXECUTION?
-CHECK_IP_CHANGE = True
-# True = only continue when IP has changed
-# False = always continue
-
-# PATH WHERE THE LAST IP SHOULD BE SAVED INBETWEEN SCRIPT EXECUTIONS
-# not needed CHECK_IP_CHANGE is false
-LAST_IP_FILE = "lastip.txt"
-
-
-import requests
-import json
-import sys
-
-if IP == 'AUTO':
-    print("Fetching IP Address...")
-    try:
-        IP = requests.get("https://api.ipify.org/").text
-    except requests.ConnectionError:
-        raise SystemExit("Failed to get IP Address from ipify")
-    print(f"Detected IP: {IP}")
-elif IP == 'ARG':
-    if (len(sys.argv) < 2):
-        raise SystemExit('No IP Address provided in commandline arguments')
-    else:
-        IP = sys.argv[1]
-
-if CHECK_IP_CHANGE:
-    try:
-        # try to read file
-        with open(LAST_IP_FILE,"r") as f:
-            if (IP == f.read()):
-                # abort if ip in file is same as current
-                print("IP Address hasn't changed. Aborting")
-                exit()
-    except IOError:
-        pass
-
-    # write current ip to file
-    with open(LAST_IP_FILE,"w") as f:
-        f.write(IP)
-
-
-def findBetween(haystack, needle1, needle2):
-    index1 = haystack.find(needle1) + len(needle1)
-    index2 = haystack.find(needle2, index1 + 1)
-    return haystack[index1 : index2]
-
-
-# will create a requests session and log you into your one.com account in that session
-def loginSession(USERNAME,  PASSWORD, TARGET_DOMAIN=''):
-    print("Logging in...")
-
-    # create requests session
-    session = requests.session()
-
-    # get admin panel to be redirected to login page
-    redirectmeurl = "https://www.one.com/admin/"
-    try:
-        r = session.get(redirectmeurl)
-    except requests.ConnectionError:
-        raise SystemExit("Connection to one.com failed.")
-
-    # find url to post login credentials to from form action attribute
-    substrstart = '<form id="kc-form-login" class="Login-form login autofill" onsubmit="login.disabled = true; return true;" action="'
-    substrend = '"'
-    posturl = findBetween(r.text, substrstart, substrend).replace('&amp;','&')
-
-    # post login data
-    logindata = {'username': USERNAME, 'password': PASSWORD, 'credentialId' : ''}
-    response = session.post(posturl, data=logindata)
-    if response.text.find("Invalid username or password.") != -1:
-        print("!!! - Invalid credentials. Exiting")
-        exit(1)
-
-    print("Login successful.")
+# #################################
+# ##                            ##
+# ##    HARDCODED VALUES        ##
+# ##                            ##
+# #################################
+# If you wish to hardcode values below and disable cli/env parsing set validate_required=False
+settings = config.parse_config(validate_required=True)
 
-    # For accounts with multiple domains it seems to still be needed to select which target domain to operate on.
-    if TARGET_DOMAIN:
-        print("Setting active domain to: {}".format(TARGET_DOMAIN))
-        selectAdminDomain(session, TARGET_DOMAIN)
+# ONE.COM LOGIN
+USERNAME = settings.username
+PASSWORD = settings.password
 
-    return session
+# YOUR DOMAIN (NOT www.example.com, www2.example.com)
+DOMAINS = settings.domains
 
+# YOUR IP ADDRESS. DEFAULTS TO RESOLVING VIA ipify.org, set to 'ARG' to take from script argument
+IP = settings.ip
 
-def selectAdminDomain(session, DOMAIN):
-    request_str = "https://www.one.com/admin/select-admin-domain.do?domain={}".format(DOMAIN)
-    session.get(request_str)
+# FORCE UPDATE DNS RECORD
+FORCE_UPDATE = settings.force_update
 
+# TTL VALUE FOR DNS RECORD
+TTL = settings.ttl
 
-# gets all DNS records on your domain.
-def getCustomRecords(session, DOMAIN):
-    print("Getting Records")
-    getres = session.get("https://www.one.com/admin/api/domains/" + DOMAIN + "/dns/custom_records").text
-    if len(getres) == 0:
-        print("!!! - No records found. Exiting")
-        exit()
-    return json.loads(getres)["result"]["data"]
+# SKIP CONFIRMATION
+SKIP_CONFIRMATION = settings.skip_confirmation
 
+# Create login session - Session is created only once outside the domain loop
+s = one_com_api.login_session(USERNAME, PASSWORD)
 
-# finds the record id of a record from it's subdomain
-def findIdBySubdomain(records, subdomain):
-    print("searching domain '" + subdomain + "'")
-    for obj in records:
-        if obj["attributes"]["prefix"] == subdomain:
-            print("Found Domain '" + subdomain + "': " + obj["id"])
-            return obj["id"]
-    return ""
+# loop through list of domains
+for DOMAIN in DOMAINS:
+    print()
+    logger.info(f"Processing domain: {DOMAIN}")
+    one_com_api.select_admin_domain(s, DOMAIN)
+    records = one_com_api.get_custom_records(s, DOMAIN)
 
+    logger.info(f"Attempting to get current DNS IP for: {DOMAIN}")
+    current_dns_ip_info = dns_utils.get_ip_and_ttl(DOMAIN)
 
-# changes the IP Address of a TYPE A record. Default TTL=3800
-def changeIP(session, ID, DOMAIN, SUBDOMAIN, IP, TTL=3600):
-    print("Changing IP on subdomain '" + SUBDOMAIN + "' - ID '" + ID + "' TO NEW IP '" + IP + "'")
+    if current_dns_ip_info:
+        current_dns_ip, current_ttl = current_dns_ip_info
+        logger.info(f"Current DNS IP for {DOMAIN}: {current_dns_ip}, TTL: {current_ttl}")
 
-    tosend = {"type":"dns_service_records","id":ID,"attributes":{"type":"A","prefix":SUBDOMAIN,"content":IP,"ttl":TTL}}
+        if not FORCE_UPDATE and current_dns_ip == IP:
+            logger.info(f"IP Address hasn't changed for {DOMAIN}. Aborting update for this domain.")
+            continue
 
-    dnsurl="https://www.one.com/admin/api/domains/" + DOMAIN + "/dns/custom_records/" + ID
-
-    sendheaders={'Content-Type': 'application/json'}
-
-    session.patch(dnsurl, data=json.dumps(tosend), headers=sendheaders)
-
-    print("Sent Change IP Request")
-
-
-
-# Create login session
-s = loginSession(USERNAME, PASSWORD, DOMAIN)
-
-# get dns records
-records = getCustomRecords(s, DOMAIN)
-#print(records)
+        update_utils.update_domain(s, DOMAIN, records, IP, TTL, current_dns_ip, SKIP_CONFIRMATION)
+    else:
+        logger.warning(f"Could not retrieve current DNS IP for {DOMAIN} after multiple retries. Proceeding with update anyway.")
+        update_utils.update_domain(s, DOMAIN, records, IP, TTL, None, SKIP_CONFIRMATION)
 
-# loop through list of subdomains
-for subdomain in SUBDOMAINS:
-    #change ip address
-    recordid = findIdBySubdomain(records, subdomain)
-    if recordid == "":
-        print("!!! - Record '" + subdomain + "' could not be found.")
-        continue
-    changeIP(s, recordid, DOMAIN, subdomain, IP, 600)
+logger.info("DDNS update process completed.")
\ No newline at end of file
diff --git a/requirements.txt b/requirements.txt
new file mode 100644
index 0000000..3450811
--- /dev/null
+++ b/requirements.txt
@@ -0,0 +1,3 @@
+requests
+tldextract
+dnspython
\ No newline at end of file
diff --git a/test/test.py b/test/test.py
new file mode 100644
index 0000000..319d139
--- /dev/null
+++ b/test/test.py
@@ -0,0 +1,127 @@
+import modules.dns_utils as dns_utils
+import modules.one_com_config as config
+import modules.one_com_api as one_com_api
+import logging
+import requests
+import unittest
+from unittest.mock import patch, Mock
+import json
+import sys  # Make sure sys is imported
+
+# Setup basic logging for tests
+logging.basicConfig(level=logging.INFO, format='%(levelname)s: %(message)s')
+
+class TestOneComDDNS(unittest.TestCase):
+
+    def test_dns_utils_get_ip_and_ttl(self):
+        ip, ttl = dns_utils.get_ip_and_ttl("google.com")
+        self.assertIsNotNone(ip)
+        self.assertIsNotNone(ttl)
+        self.assertIsInstance(ip, str)
+        self.assertIsInstance(ttl, int)
+
+        result_invalid = dns_utils.get_ip_and_ttl("invalid-domain-for-testing.com")
+        self.assertIsNone(result_invalid)
+
+    def test_one_com_config_parse_config(self):
+        with patch('sys.argv', ['test_script.py', '-u', 'testuser', '-p', 'testpass', '-d', 'test.com', '-i', '127.0.0.1', '-f', '-t', '300', '-y']):
+            settings = config.parse_config(validate_required=True)
+            self.assertEqual(settings.username, 'testuser')
+            self.assertEqual(settings.password, 'testpass')
+            self.assertEqual(settings.domains, ['test.com'])
+            self.assertEqual(settings.ip, '127.0.0.1')
+            self.assertTrue(settings.force_update)
+            self.assertEqual(settings.ttl, 300)
+            self.assertTrue(settings.skip_confirmation)
+
+    def test_one_com_config_parse_config_auto_ip(self):
+        with patch('sys.argv', ['test_script.py', '-u', 'testuser', '-p', 'testpass', '-d', 'test.com', '-i', 'AUTO']):
+            with patch('requests.get') as mock_get:
+                mock_get.return_value.text = "1.2.3.4"
+                settings = config.parse_config(validate_required=True)
+                self.assertEqual(settings.ip, "1.2.3.4")
+
+    def test_one_com_config_parse_config_auto_ip_error(self):
+        with patch('sys.argv', ['test_script.py', '-u', 'testuser', '-p', 'testpass', '-d', 'test.com', '-i', 'AUTO']):
+            with patch('requests.get') as mock_get:
+                mock_get.side_effect = requests.ConnectionError
+                with self.assertRaises(SystemExit):
+                    config.parse_config(validate_required=True)
+
+    def test_one_com_api_login_session(self):
+        with patch('requests.sessions.Session.get') as mock_get:
+            mock_get.return_value.text = '<form id="kc-form-login" class="Login-form login autofill" onsubmit="login.disabled = true; return true;" action="test_url"></form>'
+            with patch('requests.sessions.Session.post') as mock_post:
+                mock_post.return_value.text = "Success"
+                session = one_com_api.login_session("testuser", "testpass")
+                self.assertIsNotNone(session)
+        with patch('requests.sessions.Session.get') as mock_get:
+            mock_get.side_effect = requests.ConnectionError
+            with self.assertRaises(SystemExit):
+                one_com_api.login_session("testuser", "testpass")
+
+    def test_one_com_api_get_custom_records(self):
+        mock_session = Mock()
+        mock_response = Mock()
+        mock_response.raise_for_status.return_value = None
+        mock_response.text = '{"result": {"data": [{"id": "123", "attributes": {"prefix": "test"}} ]}}'
+        mock_session.get.return_value = mock_response
+
+        records = one_com_api.get_custom_records(mock_session, "test.com")
+        self.assertIsNotNone(records)
+        self.assertEqual(len(records), 1)
+        self.assertEqual(records[0]['id'], "123")
+
+        mock_session.get.side_effect = requests.exceptions.RequestException("Test Exception")
+        raised_system_exit = False
+        try:
+            one_com_api.get_custom_records(mock_session, "test.com")
+        except SystemExit:
+            raised_system_exit = True
+        self.assertTrue(raised_system_exit, "SystemExit was not raised")
+
+        mock_session.get.side_effect = None
+        mock_response.text = '{"result": {"data": "invalid json"}}'
+        mock_response.json.side_effect = json.JSONDecodeError("msg", "doc", 0)
+        mock_session.get.return_value = mock_response
+        with self.assertRaises(SystemExit):
+            one_com_api.get_custom_records(mock_session, "test.com")
+
+    def test_one_com_api_find_id_by_subdomain(self):
+        records = [{"id": "1", "attributes": {"prefix": "sub"}}, {"id": "2", "attributes": {"prefix": "other"}}]
+        record_obj = one_com_api.find_id_by_subdomain(records, "sub.test.com")
+        self.assertEqual(record_obj['id'], "1")
+
+        record_obj_not_found = one_com_api.find_id_by_subdomain(records, "nonexistent.test.com")
+        self.assertIsNone(record_obj_not_found)
+
+    def test_one_com_api_change_ip(self):
+        mock_session = Mock()
+        mock_response = Mock()
+        mock_response.raise_for_status.return_value = None
+        mock_session.patch.return_value = mock_response
+
+        record = {"id": "123", "attributes": {"ttl": 300}}
+        one_com_api.change_ip(mock_session, record, "sub.test.com", "1.2.3.4", 600)
+
+        mock_session.patch.side_effect = requests.exceptions.RequestException("Test Exception")
+        with self.assertRaises(SystemExit):
+            one_com_api.change_ip(mock_session, record, "sub.test.com", "1.2.3.4", 600)
+
+    def test_dns_utils_get_authoritative_ns(self):
+        ns_servers = dns_utils.get_authoritative_ns("google.com")
+        self.assertIsNotNone(ns_servers)
+        self.assertIsInstance(ns_servers, list)
+        self.assertGreater(len(ns_servers), 0)
+
+        ns_servers_invalid = dns_utils.get_authoritative_ns("invalid-domain-for-testing.com")
+        self.assertIsNone(ns_servers_invalid)
+
+    def test_dns_utils_get_authoritative_ns_parent(self):
+        ns_servers = dns_utils.get_authoritative_ns("sub.google.com")
+        self.assertIsNotNone(ns_servers)
+        self.assertIsInstance(ns_servers, list)
+        self.assertGreater(len(ns_servers), 0)
+
+if __name__ == '__main__':
+    unittest.main()
\ No newline at end of file