diff --git a/.gitlab-ci.yml b/.gitlab-ci.yml
index 49130335becaaf34f42f20d268b0bf4caa332393..64fdc8f0c6c9b69e1e014c80e108e76844ea98f9 100644
--- a/.gitlab-ci.yml
+++ b/.gitlab-ci.yml
@@ -12,8 +12,8 @@ test:
     # add code quality tests here
     # add unit tests here
     # add script tests here
-    # - bash tests/test_scripts_labkey_to_snakemake_table/test.sh
-    # - bash tests/test_scripts_labkey_to_snakemake_api/test.sh
+    - bash tests/test_scripts_prepare_inputs_table/test.sh
+    - bash tests/test_scripts_prepare_inputs_labkey/test.sh
     - bash tests/test_alfa/test.sh
     # add integration tests here
     - bash tests/test_create_dag_image/test.sh
diff --git a/README.md b/README.md
index c53835a9eecd64cf88ab5b14cc940b90bbcf1ca6..c8dca57c41d6a461ce6617bd42ddca6604f5634e 100644
--- a/README.md
+++ b/README.md
@@ -254,10 +254,10 @@ replacing the placeholders with the appropriate values (check out the
 help screen with option '--help' for further options and information):
 
     ```bash
-    python scripts/labkey_to_snakemake.py \
+    python scripts/prepare_inputs.py \
         --labkey-domain="my.labkey.service.io"
         --labkey-domain="/my/project/path"
-        --input-to-output-mapping="scripts/labkey_to_snakemake.dict.tsv" \
+        --input-to-output-mapping="scripts/prepare_inputs.dict.tsv" \
         --resources-dir="/path/to/my/genome/resources" \
         --output-table="config/my_run/samples.tsv" \
         --config_file="config/my_run/config.yaml" \
diff --git a/scripts/labkey_to_snakemake.dict.tsv b/scripts/prepare_inputs.dict.tsv
similarity index 100%
rename from scripts/labkey_to_snakemake.dict.tsv
rename to scripts/prepare_inputs.dict.tsv
diff --git a/scripts/labkey_to_snakemake.py b/scripts/prepare_inputs.py
similarity index 96%
rename from scripts/labkey_to_snakemake.py
rename to scripts/prepare_inputs.py
index 6cce1e4c82708e8bd4de7168358075be70ffc95a..1efc031f7767dafb393e8a549c3f6ce1fcd42443 100755
--- a/scripts/labkey_to_snakemake.py
+++ b/scripts/prepare_inputs.py
@@ -3,6 +3,7 @@
 """Create input table and config for Rhea."""
 
 import argparse
+from functools import partial
 import gzip
 import logging
 import math
@@ -17,244 +18,6 @@ import pandas as pd
 logger = logging.getLogger(__name__)
 
 
-def main():
-    """
-    Create input table and config for Rhea.
-    """
-    args = parse_cli_args()
-
-    setup_logging(
-        logger=logger,
-        verbose=args.verbose,
-        debug=args.debug,
-    )
-
-    # get input table from LabKey or CLI
-    if args.labkey_domain:
-        logger.info(
-            f"Fetching input table from LabKey instance "
-            "'{args.labkey_domain}'..."
-        )
-        input_table = fetch_labkey_table(
-            domain=args.labkey_domain,
-            container_path=args.labkey_path,
-            query_name=args.table,
-        )
-        labkey_table = expand_path(
-            '.'.join([args.output_table.name, "labkey"])
-        )
-        input_table.to_csv(
-            labkey_table,
-            sep='\t',
-            index=False,
-        )
-        from_api = True
-    else:
-        logger.info(f"Reading input table from file '{args.table}'...")
-        input_table = pd.read_csv(
-            args.table,
-            header=0,
-            sep='\t',
-            index_col=None,
-            comment='#',
-            engine='python',
-        )
-        from_api = False
-
-    # get LabKey to Snakemake sample table field mappings
-    input_dict = pd.read_csv(
-        args.input_to_output_mapping,
-        header=0,
-        sep='\t',
-        index_col=None,
-        comment='#',
-        engine='python',
-    )
-    args.input_to_output_mapping.close()
-    input_dict.set_index('snakemake', inplace=True, drop=True)
-
-    # create Snakemake table
-    logger.info("Creating Snakemake input table...")
-    snakemake_table = pd.DataFrame()
-
-    for index, row in input_table.iterrows():
-
-        # extract data from LabKey-like table
-        lk_replicate_name = row[input_dict.loc['replicate_name', 'labkey']]
-        lk_condition = row[input_dict.loc['condition', 'labkey']]
-        lk_seqmode = row[input_dict.loc['seqmode', 'labkey']]
-        lk_fastq_path = row[input_dict.loc['fastq_path', 'labkey']]
-        lk_fq1 = row[input_dict.loc['fq1', 'labkey']]
-        lk_fq2 = row[input_dict.loc['fq2', 'labkey']]
-        lk_fq1_3p = row[input_dict.loc['fq1_3p', 'labkey']]
-        lk_fq1_5p = row[input_dict.loc['fq1_5p', 'labkey']]
-        lk_fq2_3p = row[input_dict.loc['fq2_3p', 'labkey']]
-        lk_fq2_5p = row[input_dict.loc['fq2_5p', 'labkey']]
-        lk_organism = row[input_dict.loc['organism', 'labkey']]
-        lk_sd = row[input_dict.loc['sd', 'labkey']]
-        lk_mean = row[input_dict.loc['mean', 'labkey']]
-        lk_mate1_direction = row[input_dict.loc['mate1_direction', 'labkey']]
-        lk_mate2_direction = row[input_dict.loc['mate2_direction', 'labkey']]
-
-        # extract, infer or convert to Snakemake input format
-        if from_api and not os.path.isabs(lk_fastq_path):
-            anchor = os.getcwd()
-            logger.warning(
-                f"[WARNING] Don't know how to interpret relative paths "
-                "inside LabKey table. Trying with current working directory "
-                f"'{anchor}' as an anchor, but it may be better to use"
-                "absolute paths wherever possible..."
-            )
-        else:
-            anchor = os.path.abspath(os.path.dirname(args.table))
-        sample = "_".join([lk_replicate_name, lk_condition])
-        if lk_seqmode == 'PAIRED':
-            seqmode = 'pe'
-            fq2 = expand_path(
-                lk_fastq_path,
-                lk_fq2,
-                anchor=anchor,
-            )
-        elif lk_seqmode == 'SINGLE':
-            seqmode = 'se'
-            fq2 = "XXXXXXXXXXXXXXX"
-        else:
-            logger.error(
-                f"[ERROR] Illegal sequencing mode '{lk_seqmode}' in row "
-                f"{index+1}."
-            )
-            sys.exit("Execution aborted.")
-        fq1 = expand_path(
-            lk_fastq_path,
-            lk_fq1,
-            anchor=anchor,
-        )
-        read_length = get_read_length(fq1)
-        index_size = read_length - 1
-        kmer = kmer_from_read_length(read_length)
-        fq1_3p = lk_fq1_3p
-        fq1_5p = lk_fq1_5p
-        fq2_3p = lk_fq2_3p
-        fq2_5p = lk_fq2_5p
-        organism = lk_organism.replace(' ', '_').lower()
-        gtf = expand_path(
-            args.resources_dir,
-            organism,
-            'annotation.gtf',
-        )
-        genome = expand_path(
-            args.resources_dir,
-            organism,
-            'genome.fa',
-        )
-        sd = lk_sd
-        mean = lk_mean
-        fq1_polya_3p, fq1_polya_5p = get_polya_adapter_seqs(lk_mate1_direction)
-        fq2_polya_3p, fq2_polya_5p = get_polya_adapter_seqs(lk_mate2_direction)
-        kallisto_directionality = get_strand_param_kallisto(lk_mate1_direction)
-        alfa_directionality = get_strand_param_alfa(lk_mate1_direction)
-        alfa_plus, alfa_minus = get_strand_names_alfa(lk_mate1_direction)
-
-        # construct row in Snakemake input table
-        snakemake_table.loc[index, 'sample'] = sample
-        snakemake_table.loc[index, 'seqmode'] = seqmode
-        snakemake_table.loc[index, 'fq1'] = fq1
-        snakemake_table.loc[index, 'fq2'] = fq2
-        snakemake_table.loc[index, 'index_size'] = index_size
-        snakemake_table.loc[index, 'kmer'] = kmer
-        snakemake_table.loc[index, 'fq1_3p'] = fq1_3p
-        snakemake_table.loc[index, 'fq1_5p'] = fq1_5p
-        snakemake_table.loc[index, 'fq2_3p'] = fq2_3p
-        snakemake_table.loc[index, 'fq2_5p'] = fq2_5p
-        snakemake_table.loc[index, 'organism'] = organism
-        snakemake_table.loc[index, 'gtf'] = gtf
-        snakemake_table.loc[index, 'genome'] = genome
-        snakemake_table.loc[index, 'sd'] = sd
-        snakemake_table.loc[index, 'mean'] = mean
-        snakemake_table.loc[index, 'kallisto_directionality'] = \
-            kallisto_directionality
-        snakemake_table.loc[index, 'alfa_directionality'] = alfa_directionality
-        snakemake_table.loc[index, 'alfa_plus'] = alfa_plus
-        snakemake_table.loc[index, 'alfa_minus'] = alfa_minus
-
-        # add CLI argument-dependent parameters
-        snakemake_table.loc[index, 'multimappers'] = args.multimappers
-        snakemake_table.loc[index, 'soft_clip'] = args.soft_clip
-        snakemake_table.loc[index, 'pass_mode'] = args.pass_mode
-        snakemake_table.loc[index, 'libtype'] = args.libtype
-        if args.trim_polya is True:
-            snakemake_table.loc[index, 'fq1_polya_3p'] = fq1_polya_3p
-            snakemake_table.loc[index, 'fq1_polya_5p'] = fq1_polya_5p
-            snakemake_table.loc[index, 'fq2_polya_3p'] = fq2_polya_3p
-            snakemake_table.loc[index, 'fq2_polya_5p'] = fq2_polya_5p
-
-    # adjust sample table format
-    snakemake_table.fillna('XXXXXXXXXXXXXXX', inplace=True)
-    snakemake_table = snakemake_table.astype(
-        {
-            "sd": int,
-            "mean": int,
-            "multimappers": int,
-            "kmer": int,
-            "index_size": int,
-        }
-    )
-
-    # write Snakemake sample table
-    logger.info("Writing Snakemake input table...")
-    snakemake_table.to_csv(
-        args.output_table,
-        sep='\t',
-        header=True,
-        index=False)
-    args.output_table.close()
-
-    # compile entries for Snakemake config file
-    logger.info("Creating Snakemake config file...")
-    results_dir = expand_path(
-        args.output_dir,
-        "results",
-    )
-    log_dir = expand_path(
-        args.output_dir,
-        "logs",
-    )
-    kallisto_indexes = expand_path(
-        results_dir,
-        "kallisto_indexes",
-    )
-    salmon_indexes = expand_path(
-        results_dir,
-        "salmon_indexes",
-    )
-    star_indexes = expand_path(
-        results_dir,
-        "star_indexes",
-    )
-    alfa_indexes = expand_path(
-        results_dir,
-        "alfa_indexes",
-    )
-
-    # write Snakemake config file
-    logger.info("Writing Snakemake config file...")
-    config_file_content = f'''---
-  samples: "{expand_path(args.output_table.name)}"
-  output_dir: "{results_dir}"
-  log_dir: "{log_dir}"
-  kallisto_indexes: "{kallisto_indexes}"
-  salmon_indexes: "{salmon_indexes}"
-  star_indexes: "{star_indexes}"
-  alfa_indexes: "{alfa_indexes}"
-  report_description: "{args.description}"
-  report_logo: "{args.logo}"
-  report_url: "{args.url}"
-...
-'''
-    args.config_file.write(config_file_content)
-    args.config_file.close()
-
-
 def parse_cli_args() -> argparse.Namespace:
     """
     Parses command line arguments.
@@ -298,7 +61,7 @@ def parse_cli_args() -> argparse.Namespace:
         type=argparse.FileType('r'),
         default=os.path.join(
             os.path.dirname(__file__),
-            'labkey_to_snakemake.dict.tsv',
+            'prepare_inputs.dict.tsv',
         ),
         help="lookup table with mappings from input (LabKey or LabKey-like) "
              "to output (Snakemake) table; default: '%(default)s'",
@@ -335,6 +98,12 @@ def parse_cli_args() -> argparse.Namespace:
              "(default: %(default)s)",
         metavar="DIR",
     )
+    parser.add_argument(
+        "--no-process-paths",
+        action="store_true",
+        default=False,
+        help="do not attempt to create absolute paths in output files",
+    )
 
     behavior = parser.add_argument_group("workflow behavior")
     behavior.add_argument(
@@ -415,7 +184,7 @@ def parse_cli_args() -> argparse.Namespace:
 
     if args.logo:
         args.logo.close()
-        args.logo = os.path.abspath(args.logo.name)
+        args.logo = args.logo.name
     else:
         args.logo = ""
 
@@ -510,7 +279,7 @@ def get_read_length(file: str) -> int:
 
 
 def kmer_from_read_length(
-    l: int,
+    length: int,
     k_max: int = 31,
     k_min: int = 11,
 ) -> int:
@@ -523,7 +292,7 @@ def kmer_from_read_length(
     https://salmon.readthedocs.io/en/latest/salmon.html#preparing-transcriptome-indices-mapping-based-mode
     https://groups.google.com/d/msg/sailfish-users/fphjX7OIGzY/bMBwlCaZAgAJ
 
-    :param l: length of read in nucleotides
+    :param length: length of read in nucleotides
     :param k_max: maximum allowed k-mer size
     :param k_min: minimum allowed k-mer size
 
@@ -531,9 +300,9 @@ def kmer_from_read_length(
         where k is biggest odd integer that fulfills k < l / 2
     """
     k = k_max
-    if l < 2 * k_max + 1:
+    if length < 2 * k_max + 1:
         # ensure kmer is smaller than half of read length
-        k = math.floor((l - 1) / 2)
+        k = math.floor((length - 1) / 2)
         # ensure kmer is odd
         if not k % 2:
             k -= 1
@@ -639,6 +408,7 @@ def expand_path(
     *args: str,
     anchor: str = os.getcwd(),
     expand: bool = True,
+    no_abs: bool = False,
 ) -> str:
     """
     Constructs absolute path.
@@ -654,10 +424,14 @@ def expand_path(
         the path will be returned without considering the anchor
     :param expand: whether environment variables and user directories (e.g,
         `~`) shall be expanded
+    :param join_only: path fragments in args are joined, but no further
+        processing is done
 
     :returns: absolute path
     """
     suffix = os.path.join(*args)
+    if no_abs:
+        return suffix
     if os.path.isabs(suffix):
         return os.path.normpath(suffix)
     if expand:
@@ -668,17 +442,257 @@ def expand_path(
         )
     if os.path.isabs(suffix):
         return os.path.normpath(suffix)
-    if expand:
-        anchor = os.path.expanduser(
-            os.path.expandvars(
-                anchor
-            )
+    anchor = os.path.expanduser(
+        os.path.expandvars(
+            anchor
         )
+    )
     path = os.path.join(anchor, suffix)
     return os.path.normpath(path)
 
 
+def main(args):
+    """
+    Create input table and config for Rhea.
+    """
+    setup_logging(
+        logger=logger,
+        verbose=args.verbose,
+        debug=args.debug,
+    )
+
+    # get input table from LabKey or CLI
+    if args.labkey_domain:
+        logger.info(
+            f"Fetching input table from LabKey instance "
+            "'{args.labkey_domain}'..."
+        )
+        input_table = fetch_labkey_table(
+            domain=args.labkey_domain,
+            container_path=args.labkey_path,
+            query_name=args.table,
+        )
+        labkey_table = expand_path(
+            '.'.join([args.output_table.name, "labkey"])
+        )
+        input_table.to_csv(
+            labkey_table,
+            sep='\t',
+            index=False,
+        )
+        from_api = True
+    else:
+        logger.info(f"Reading input table from file '{args.table}'...")
+        input_table = pd.read_csv(
+            args.table,
+            header=0,
+            sep='\t',
+            index_col=None,
+            comment='#',
+            engine='python',
+        )
+        from_api = False
+
+    # get LabKey to Snakemake sample table field mappings
+    input_dict = pd.read_csv(
+        args.input_to_output_mapping,
+        header=0,
+        sep='\t',
+        index_col=None,
+        comment='#',
+        engine='python',
+    )
+    args.input_to_output_mapping.close()
+    input_dict.set_index('snakemake', inplace=True, drop=True)
+
+    # create Snakemake table
+    logger.info("Creating Snakemake input table...")
+    snakemake_table = pd.DataFrame()
+
+    for index, row in input_table.iterrows():
+
+        # extract data from LabKey-like table
+        lk_replicate_name = row[input_dict.loc['replicate_name', 'labkey']]
+        lk_condition = row[input_dict.loc['condition', 'labkey']]
+        lk_seqmode = row[input_dict.loc['seqmode', 'labkey']]
+        lk_fastq_path = row[input_dict.loc['fastq_path', 'labkey']]
+        lk_fq1 = row[input_dict.loc['fq1', 'labkey']]
+        lk_fq2 = row[input_dict.loc['fq2', 'labkey']]
+        lk_fq1_3p = row[input_dict.loc['fq1_3p', 'labkey']]
+        lk_fq1_5p = row[input_dict.loc['fq1_5p', 'labkey']]
+        lk_fq2_3p = row[input_dict.loc['fq2_3p', 'labkey']]
+        lk_fq2_5p = row[input_dict.loc['fq2_5p', 'labkey']]
+        lk_organism = row[input_dict.loc['organism', 'labkey']]
+        lk_sd = row[input_dict.loc['sd', 'labkey']]
+        lk_mean = row[input_dict.loc['mean', 'labkey']]
+        lk_mate1_direction = row[input_dict.loc['mate1_direction', 'labkey']]
+        lk_mate2_direction = row[input_dict.loc['mate2_direction', 'labkey']]
+
+        # extract, infer or convert to Snakemake input format
+        if from_api and not os.path.isabs(lk_fastq_path):
+            anchor = os.getcwd()
+            logger.warning(
+                f"[WARNING] Don't know how to interpret relative paths "
+                "inside LabKey table. Trying with current working directory "
+                f"'{anchor}' as an anchor, but it may be better to use"
+                "absolute paths wherever possible..."
+            )
+        else:
+            anchor = os.path.abspath(os.path.dirname(args.table))
+        sample = "_".join([lk_replicate_name, lk_condition])
+        if lk_seqmode == 'PAIRED':
+            seqmode = 'pe'
+            fq2 = expand_path(
+                lk_fastq_path,
+                lk_fq2,
+                anchor=anchor,
+            )
+        elif lk_seqmode == 'SINGLE':
+            seqmode = 'se'
+            fq2 = "XXXXXXXXXXXXXXX"
+        else:
+            logger.error(
+                f"[ERROR] Illegal sequencing mode '{lk_seqmode}' in row "
+                f"{index+1}."
+            )
+            sys.exit("Execution aborted.")
+        fq1 = expand_path(
+            lk_fastq_path,
+            lk_fq1,
+            anchor=anchor,
+        )
+        read_length = get_read_length(fq1)
+        index_size = read_length - 1
+        kmer = kmer_from_read_length(read_length)
+        fq1_3p = lk_fq1_3p
+        fq1_5p = lk_fq1_5p
+        fq2_3p = lk_fq2_3p
+        fq2_5p = lk_fq2_5p
+        organism = lk_organism.replace(' ', '_').lower()
+        gtf = expand_path(
+            args.resources_dir,
+            organism,
+            'annotation.gtf',
+        )
+        genome = expand_path(
+            args.resources_dir,
+            organism,
+            'genome.fa',
+        )
+        sd = lk_sd
+        mean = lk_mean
+        fq1_polya_3p, fq1_polya_5p = get_polya_adapter_seqs(lk_mate1_direction)
+        fq2_polya_3p, fq2_polya_5p = get_polya_adapter_seqs(lk_mate2_direction)
+        kallisto_directionality = get_strand_param_kallisto(lk_mate1_direction)
+        alfa_directionality = get_strand_param_alfa(lk_mate1_direction)
+        alfa_plus, alfa_minus = get_strand_names_alfa(lk_mate1_direction)
+
+        # construct row in Snakemake input table
+        snakemake_table.loc[index, 'sample'] = sample
+        snakemake_table.loc[index, 'seqmode'] = seqmode
+        snakemake_table.loc[index, 'fq1'] = fq1
+        snakemake_table.loc[index, 'fq2'] = fq2
+        snakemake_table.loc[index, 'index_size'] = index_size
+        snakemake_table.loc[index, 'kmer'] = kmer
+        snakemake_table.loc[index, 'fq1_3p'] = fq1_3p
+        snakemake_table.loc[index, 'fq1_5p'] = fq1_5p
+        snakemake_table.loc[index, 'fq2_3p'] = fq2_3p
+        snakemake_table.loc[index, 'fq2_5p'] = fq2_5p
+        snakemake_table.loc[index, 'organism'] = organism
+        snakemake_table.loc[index, 'gtf'] = gtf
+        snakemake_table.loc[index, 'genome'] = genome
+        snakemake_table.loc[index, 'sd'] = sd
+        snakemake_table.loc[index, 'mean'] = mean
+        snakemake_table.loc[index, 'kallisto_directionality'] = \
+            kallisto_directionality
+        snakemake_table.loc[index, 'alfa_directionality'] = alfa_directionality
+        snakemake_table.loc[index, 'alfa_plus'] = alfa_plus
+        snakemake_table.loc[index, 'alfa_minus'] = alfa_minus
+
+        # add CLI argument-dependent parameters
+        snakemake_table.loc[index, 'multimappers'] = args.multimappers
+        snakemake_table.loc[index, 'soft_clip'] = args.soft_clip
+        snakemake_table.loc[index, 'pass_mode'] = args.pass_mode
+        snakemake_table.loc[index, 'libtype'] = args.libtype
+        if args.trim_polya is True:
+            snakemake_table.loc[index, 'fq1_polya_3p'] = fq1_polya_3p
+            snakemake_table.loc[index, 'fq1_polya_5p'] = fq1_polya_5p
+            snakemake_table.loc[index, 'fq2_polya_3p'] = fq2_polya_3p
+            snakemake_table.loc[index, 'fq2_polya_5p'] = fq2_polya_5p
+
+    # adjust sample table format
+    snakemake_table.fillna('XXXXXXXXXXXXXXX', inplace=True)
+    snakemake_table = snakemake_table.astype(
+        {
+            "sd": int,
+            "mean": int,
+            "multimappers": int,
+            "kmer": int,
+            "index_size": int,
+        }
+    )
+
+    # write Snakemake sample table
+    logger.info("Writing Snakemake input table...")
+    snakemake_table.to_csv(
+        args.output_table,
+        sep='\t',
+        header=True,
+        index=False)
+    args.output_table.close()
+
+    # compile entries for Snakemake config file
+    logger.info("Creating Snakemake config file...")
+    results_dir = expand_path(
+        args.output_dir,
+        "results",
+    )
+    log_dir = expand_path(
+        args.output_dir,
+        "logs",
+    )
+    kallisto_indexes = expand_path(
+        results_dir,
+        "kallisto_indexes",
+    )
+    salmon_indexes = expand_path(
+        results_dir,
+        "salmon_indexes",
+    )
+    star_indexes = expand_path(
+        results_dir,
+        "star_indexes",
+    )
+    alfa_indexes = expand_path(
+        results_dir,
+        "alfa_indexes",
+    )
+
+    # write Snakemake config file
+    logger.info("Writing Snakemake config file...")
+    config_file_content = f'''---
+  samples: "{expand_path(args.output_table.name)}"
+  output_dir: "{results_dir}"
+  log_dir: "{log_dir}"
+  kallisto_indexes: "{kallisto_indexes}"
+  salmon_indexes: "{salmon_indexes}"
+  star_indexes: "{star_indexes}"
+  alfa_indexes: "{alfa_indexes}"
+  report_description: "{args.description}"
+  report_logo: "{args.logo}"
+  report_url: "{args.url}"
+...
+'''
+    args.config_file.write(config_file_content)
+    args.config_file.close()
+
+
 if __name__ == '__main__':
-    main()
+    args = parse_cli_args()
+
+    # Set default according to CLI arg
+    expand_path = partial(expand_path, no_abs=args.no_process_paths)  # type: ignore
+
+    main(args)
     logger.info("Program completed successfully.")
     sys.exit(0)
diff --git a/tests/test_scripts_labkey_to_snakemake_table/expected_output.md5 b/tests/test_scripts_labkey_to_snakemake_table/expected_output.md5
deleted file mode 100644
index abbf9abd4b49d63efb6d675a01d87eb5945c4b72..0000000000000000000000000000000000000000
--- a/tests/test_scripts_labkey_to_snakemake_table/expected_output.md5
+++ /dev/null
@@ -1,2 +0,0 @@
-057cbd5757ca7f0b94909eeeca531af3  config.yaml
-34422785b7cc77d1aac73d25e767dc2d  samples.tsv
diff --git a/tests/test_scripts_labkey_to_snakemake_api/expected_output.md5 b/tests/test_scripts_prepare_inputs_labkey/expected_output.md5
similarity index 100%
rename from tests/test_scripts_labkey_to_snakemake_api/expected_output.md5
rename to tests/test_scripts_prepare_inputs_labkey/expected_output.md5
diff --git a/tests/test_scripts_labkey_to_snakemake_api/test.sh b/tests/test_scripts_prepare_inputs_labkey/test.sh
similarity index 92%
rename from tests/test_scripts_labkey_to_snakemake_api/test.sh
rename to tests/test_scripts_prepare_inputs_labkey/test.sh
index 4f18c4203bf0699a5e7f4f644a95d442592df687..3f8b721e5632b38e8d131c64decf976fcdadc90c 100755
--- a/tests/test_scripts_labkey_to_snakemake_api/test.sh
+++ b/tests/test_scripts_prepare_inputs_labkey/test.sh
@@ -30,10 +30,10 @@ password ${LABKEY_PASS}
 EOF
 
 # Run tests
-python "../../scripts/labkey_to_snakemake.py" \
+python "../../scripts/prepare_inputs.py" \
     --labkey-domain="${LABKEY_HOST}" \
     --labkey-path="/Zavolan Group/TEST_LABKEY" \
-    --input-to-output-mapping="../../scripts/labkey_to_snakemake.dict.tsv" \
+    --input-to-output-mapping="../../scripts/prepare_inputs.dict.tsv" \
     --resources-dir="../input_files" \
     --output-table="samples.tsv" \
     --config-file="config.yaml" \
diff --git a/tests/test_scripts_prepare_inputs_table/expected_output.md5 b/tests/test_scripts_prepare_inputs_table/expected_output.md5
new file mode 100644
index 0000000000000000000000000000000000000000..53afed559996a1e89802ff5bb9307351b8004fdf
--- /dev/null
+++ b/tests/test_scripts_prepare_inputs_table/expected_output.md5
@@ -0,0 +1,2 @@
+40bd0f0fcecdd0d9bc932f63c2811478  config.yaml
+c8dcc5a203e9046806c4090525960151  samples.tsv
diff --git a/tests/test_scripts_labkey_to_snakemake_table/input_table.tsv b/tests/test_scripts_prepare_inputs_table/input_table.tsv
similarity index 100%
rename from tests/test_scripts_labkey_to_snakemake_table/input_table.tsv
rename to tests/test_scripts_prepare_inputs_table/input_table.tsv
diff --git a/tests/test_scripts_labkey_to_snakemake_table/test.sh b/tests/test_scripts_prepare_inputs_table/test.sh
similarity index 86%
rename from tests/test_scripts_labkey_to_snakemake_table/test.sh
rename to tests/test_scripts_prepare_inputs_table/test.sh
index e60c4fc0884494340d8efad5d14809c33a1b8c76..ebd9391f2303cfe8e251c127d5748faa68ea7ba8 100755
--- a/tests/test_scripts_labkey_to_snakemake_table/test.sh
+++ b/tests/test_scripts_prepare_inputs_table/test.sh
@@ -21,13 +21,15 @@ script_dir="$(cd "$(dirname "${BASH_SOURCE[0]}")" >/dev/null 2>&1 && pwd)"
 cd $script_dir/
 
 # Run tests
-python "../../scripts/labkey_to_snakemake.py" \
-    --input-to-output-mapping="../../scripts/labkey_to_snakemake.dict.tsv" \
+python "../../scripts/prepare_inputs.py" \
+    --input-to-output-mapping="../../scripts/prepare_inputs.dict.tsv" \
     --resources-dir="../input_files" \
     --output-table="samples.tsv" \
     --config-file="config.yaml" \
     --multimappers='10' \
     --logo="../../images/logo.128px.png" \
+    --output-dir="" \
+    --no-process-paths \
     "input_table.tsv"