Repository: uccser/verto

Issue:
Add optional argument to skip adding interactive thumbnails to required files
Add a configurable parameter to skip adding interactive thumbnails to required files.

Discussion:

Patch:
diff --git a/docs/source/usage.rst b/docs/source/usage.rst
index 0f1e3c2..1f3548c 100644
--- a/docs/source/usage.rst
+++ b/docs/source/usage.rst
@@ -51,37 +51,43 @@ Once the module is imported, you can create a Verto converter creating an Verto
 
 - ``extensions`` -  A list of extra Markdown extensions to run in the converter. Details on how to use this parameter can be found on the :doc:`extensions` page.
 
-- ``custom_argument_rules`` - A dictionary to modify the default argument rules for each tag. The default rules can found by reading the documentation for each tag.
+- ``settings`` - A dictionary of settings to override default Verto settings. The following settings are available:
 
-  - *For example:* By default, the ``image-inline`` tag requires alt text to be given, to change this, the following custom argument rules would be used:
+  - ``add_default_interactive_thumbnails_to_required_files`` - Boolean stating whether default interactive thumbnail filepaths should be added to the required files set of images. Default is ``True``.
 
-    .. code-block:: python
+  - ``add_custom_interactive_thumbnails_to_required_files`` - Boolean stating whether custom interactive thumbnail filepaths provided as tag arguments should be added to the required files set of images. External images are never added. Default is ``True``.
+
+  - ``processor_argument_overrides`` - A dictionary to modify the default argument rules for each tag. The default rules can found by reading the documentation for each tag.
+
+    - *For example:* By default, the ``image-inline`` tag requires alt text to be given, to change this, the following custom argument rules would be used:
+
+      .. code-block:: python
 
-      {
-        "image-inline": {
-          "alt": False
+        {
+          "image-inline": {
+            "alt": False
+          }
         }
-      }
 
- .. warning::
+  .. warning::
 
-   Some tags have multiple processors behind them (for example, the ``image-inline``, ``image-container`` and ``image-tag`` processors are all used for images).
-   This means that if you would like to change the default rules of one or more of their arguments, this will need to be done for each of the processors
-   individually. For example, to set the ``alt`` argument as ``False`` for all images, the custom argument rules would look as follows:
+    Some tags have multiple processors behind them (for example, the ``image-inline``, ``image-container`` and ``image-tag`` processors are all used for images).
+    This means that if you would like to change the default rules of one or more of their arguments, this will need to be done for each of the processors
+    individually. For example, to set the ``alt`` argument as ``False`` for all images, the custom argument rules would look as follows:
 
-   .. code-block:: python
+    .. code-block:: python
 
-      {
-        "image-inline": {
-          "alt": False
-        },
-        "image-tag": {
-          "alt": False
-        },
-        "image-container": {
-          "alt": False
+        {
+          "image-inline": {
+            "alt": False
+          },
+          "image-tag": {
+            "alt": False
+          },
+          "image-container": {
+            "alt": False
+          }
         }
-      }
 
 
 Step 3: Convert Markdown with converter
diff --git a/verto/Verto.py b/verto/Verto.py
index 6c4de91..a902765 100644
--- a/verto/Verto.py
+++ b/verto/Verto.py
@@ -31,7 +31,7 @@ class Verto(object):
     to HTML.
     '''
 
-    def __init__(self, processors=DEFAULT_PROCESSORS, html_templates={}, extensions=[], custom_argument_rules={}):
+    def __init__(self, processors=DEFAULT_PROCESSORS, html_templates={}, extensions=[], custom_settings={}):
         '''Creates a Verto object.
 
         Args:
@@ -45,13 +45,12 @@ class Verto(object):
                 eg: {'image': '<img src={{ source }}>'}
             extensions: A list of extra extensions to run on the
                 markdown package.
-            custom_argument_rules: A dictionary of rules for the processors to
-                override default processor rules.
+            custom_settings: A dictionary of settings to override default settings.
         '''
         self.processors = set(processors)
         self.html_templates = dict(html_templates)
         self.extensions = list(extensions)
-        self.custom_argument_rules = custom_argument_rules
+        self.custom_settings = custom_settings
         self.create_converter()
 
     def create_converter(self):
@@ -60,7 +59,7 @@ class Verto(object):
             processors=self.processors,
             html_templates=self.html_templates,
             extensions=self.extensions,
-            custom_argument_rules=self.custom_argument_rules,
+            custom_settings=self.custom_settings,
         )
         all_extensions = self.extensions + [self.verto_extension]
         self.converter = markdown.Markdown(extensions=all_extensions)
diff --git a/verto/VertoExtension.py b/verto/VertoExtension.py
index a9c0761..d15dada 100644
--- a/verto/VertoExtension.py
+++ b/verto/VertoExtension.py
@@ -50,7 +50,7 @@ class VertoExtension(Extension):
     the Verto converter.
     '''
 
-    def __init__(self, processors=[], html_templates={}, extensions=[], custom_argument_rules={}, *args, **kwargs):
+    def __init__(self, processors=[], html_templates={}, extensions=[], custom_settings={}, *args, **kwargs):
         '''
         Args:
             processors: A set of processor names given as strings for which
@@ -62,11 +62,12 @@ class VertoExtension(Extension):
                 as values.
                 eg: {'image': '<img src={{ source }}>'}
             extensions: A list of extra extensions for compatibility.
+            custom_settings: A dictionary of user settings to override defaults.
         '''
         super().__init__(*args, **kwargs)
         self.jinja_templates = self.loadJinjaTemplates(html_templates)
         self.processors = processors
-        self.custom_argument_rules = custom_argument_rules
+        self.settings = self.get_settings(custom_settings)
         self.processor_info = self.loadProcessorInfo()
         self.title = None
         self.heading_tree = None
@@ -226,7 +227,7 @@ class VertoExtension(Extension):
         '''
         json_data = pkg_resources.resource_string('verto', 'processor-info.json').decode('utf-8')
         json_data = json.loads(json_data, object_pairs_hook=OrderedDict)
-        if len(self.custom_argument_rules) != 0:
+        if len(self.settings['processor_argument_overrides']) != 0:
             self.modify_rules(json_data)
         return json_data
 
@@ -261,7 +262,7 @@ class VertoExtension(Extension):
             json_data: dictionary of rules for processors parsing tags,
                 with modified rules arcording to custom rules given.
         '''
-        for processor, arguments_to_modify in self.custom_argument_rules.items():
+        for processor, arguments_to_modify in self.settings['processor_argument_overrides'].items():
             if processor not in self.processors:
                 msg = '\'{}\' is not a valid processor.'.format(processor)
                 raise CustomArgumentRulesError(processor, msg)
@@ -273,3 +274,22 @@ class VertoExtension(Extension):
                     msg = '\'{}\' is not a valid argument for the \'{}\' processor.'.format(argument[0], processor)
                     raise CustomArgumentRulesError(argument[0], msg)
         return json_data
+
+    def get_settings(self, user_settings):
+        '''Return the settings for the Verto extension.
+
+        Any provided user settings override the default settings.
+
+        Args:
+            user_settings (dict): User overrides of settings.
+
+        Returns:
+            Dictionary of settings.
+        '''
+        settings = {
+            'add_default_interactive_thumbnails_to_required_files': True,
+            'add_custom_interactive_thumbnails_to_required_files': True,
+            'processor_argument_overrides': dict(),
+        }
+        settings.update(user_settings)
+        return settings
diff --git a/verto/processors/GenericContainerBlockProcessor.py b/verto/processors/GenericContainerBlockProcessor.py
index 2524789..cedcf88 100644
--- a/verto/processors/GenericContainerBlockProcessor.py
+++ b/verto/processors/GenericContainerBlockProcessor.py
@@ -15,6 +15,7 @@ class GenericContainerBlockProcessor(BlockProcessor):
         '''
         super().__init__(*args, **kwargs)
         self.processor = processor
+        self.settings = ext.settings
         tag_argument = ext.processor_info[self.processor].get('tag_argument', self.processor)
         self.p_start = re.compile(r'(^|\n) *\{{{0} ?(?P<args>[^\}}]*)(?<! end)\}} *(\n|$)'.format(tag_argument))
         self.p_end = re.compile(r'(^|\n) *\{{{0} end\}} *(\n|$)'.format(tag_argument))
diff --git a/verto/processors/GenericTagBlockProcessor.py b/verto/processors/GenericTagBlockProcessor.py
index ff8587d..6e1113e 100644
--- a/verto/processors/GenericTagBlockProcessor.py
+++ b/verto/processors/GenericTagBlockProcessor.py
@@ -15,6 +15,7 @@ class GenericTagBlockProcessor(BlockProcessor):
         '''
         super().__init__(*args, **kwargs)
         self.processor = processor
+        self.settings = ext.settings
         tag_argument = ext.processor_info[self.processor].get('tag_argument', self.processor)
         self.pattern = re.compile(r'(^|\n) *\{{{0} ?(?P<args>[^\}}]*)(?<! end)\}} *(\n|$)'.format(tag_argument))
         self.arguments = ext.processor_info[self.processor]['arguments']
diff --git a/verto/processors/InteractiveContainerBlockProcessor.py b/verto/processors/InteractiveContainerBlockProcessor.py
index 2451f4f..0a191a1 100644
--- a/verto/processors/InteractiveContainerBlockProcessor.py
+++ b/verto/processors/InteractiveContainerBlockProcessor.py
@@ -4,6 +4,9 @@ from verto.errors.InteractiveMissingTextError import InteractiveMissingTextError
 
 import re
 
+DEFAULT_THUMBNAIL = 'default'
+CUSTOM_THUMBNAIL = 'custom'
+
 
 class InteractiveContainerBlockProcessor(GenericContainerBlockProcessor):
     ''' Searches a Document for interactive tags e.g.
@@ -74,13 +77,19 @@ class InteractiveContainerBlockProcessor(GenericContainerBlockProcessor):
 
             if thumbnail_file_path is not None:
                 del argument_values[argument]
+                thumbnail_type = CUSTOM_THUMBNAIL
             else:
                 thumbnail_file_path = 'interactives/{}/img/thumbnail.png'.format(slug)
+                thumbnail_type = DEFAULT_THUMBNAIL
 
             external_path_match = re.search(r'^http', thumbnail_file_path)
             if external_path_match is None:  # internal image
                 thumbnail_file_relative = True
-                self.required_images.add(thumbnail_file_path)
+                add_default = self.settings['add_default_interactive_thumbnails_to_required_files']
+                add_custom = self.settings['add_custom_interactive_thumbnails_to_required_files']
+                if (thumbnail_type == DEFAULT_THUMBNAIL and add_default) or \
+                   (thumbnail_type == CUSTOM_THUMBNAIL and add_custom):
+                    self.required_images.add(thumbnail_file_path)
             else:
                 thumbnail_file_relative = False
 
diff --git a/verto/processors/InteractiveTagBlockProcessor.py b/verto/processors/InteractiveTagBlockProcessor.py
index e17fecc..8dd8dc1 100644
--- a/verto/processors/InteractiveTagBlockProcessor.py
+++ b/verto/processors/InteractiveTagBlockProcessor.py
@@ -1,6 +1,9 @@
 from verto.processors.GenericTagBlockProcessor import GenericTagBlockProcessor
 import re
 
+DEFAULT_THUMBNAIL = 'default'
+CUSTOM_THUMBNAIL = 'custom'
+
 
 class InteractiveTagBlockProcessor(GenericTagBlockProcessor):
     '''Searches a Document for interactive tags:
@@ -56,13 +59,19 @@ class InteractiveTagBlockProcessor(GenericTagBlockProcessor):
 
             if thumbnail_file_path is not None:
                 del argument_values[argument]
+                thumbnail_type = CUSTOM_THUMBNAIL
             else:
                 thumbnail_file_path = 'interactives/{}/img/thumbnail.png'.format(slug)
+                thumbnail_type = DEFAULT_THUMBNAIL
 
             external_path_match = re.search(r'^http', thumbnail_file_path)
             if external_path_match is None:  # internal image
                 thumbnail_file_relative = True
-                self.required_images.add(thumbnail_file_path)
+                add_default = self.settings['add_default_interactive_thumbnails_to_required_files']
+                add_custom = self.settings['add_custom_interactive_thumbnails_to_required_files']
+                if (thumbnail_type == DEFAULT_THUMBNAIL and add_default) or \
+                   (thumbnail_type == CUSTOM_THUMBNAIL and add_custom):
+                    self.required_images.add(thumbnail_file_path)
             else:
                 thumbnail_file_relative = False
 


Test patch:
diff --git a/verto/tests/BlockquoteTest.py b/verto/tests/BlockquoteTest.py
index 01d23a4..6a03cbd 100644
--- a/verto/tests/BlockquoteTest.py
+++ b/verto/tests/BlockquoteTest.py
@@ -178,14 +178,16 @@ class BlockquoteTest(ProcessorTest):
     def test_custom_arguments_source_true(self):
         '''Tests to ensure that blockquote tag is rendered correctly when source argument is required.
         '''
-        custom_argument_rules = {
-            "blockquote": {
-                "source": True
+        settings = {
+            'processor_argument_overrides': {
+                'blockquote': {
+                    'source': True
+                }
             }
         }
         verto_extension_custom_rules = VertoExtension(
             processors=[self.processor_name],
-            custom_argument_rules=custom_argument_rules
+            custom_settings=settings
         )
 
         test_string = self.read_test_file(self.processor_name, 'source_true.md')
@@ -200,14 +202,16 @@ class BlockquoteTest(ProcessorTest):
     def test_custom_arguments_source_true_missing_argument(self):
         '''Tests to ensure that blockquote tag raises errors when source argument is required and not given.
         '''
-        custom_argument_rules = {
-            "blockquote": {
-                "source": True
+        settings = {
+            'processor_argument_overrides': {
+                'blockquote': {
+                    'source': True
+                }
             }
         }
         verto_extension_custom_rules = VertoExtension(
             processors=[self.processor_name],
-            custom_argument_rules=custom_argument_rules
+            custom_settings=settings
         )
 
         test_string = self.read_test_file(self.processor_name, 'source_true_missing_argument.md')
@@ -220,14 +224,16 @@ class BlockquoteTest(ProcessorTest):
     def test_custom_arguments_alignment_true(self):
         '''Tests to ensure that blockquote tag is rendered correctly when alignment argument is required.
         '''
-        custom_argument_rules = {
-            "blockquote": {
-                "alignment": True
+        settings = {
+            'processor_argument_overrides': {
+                'blockquote': {
+                    'alignment': True
+                }
             }
         }
         verto_extension_custom_rules = VertoExtension(
             processors=[self.processor_name],
-            custom_argument_rules=custom_argument_rules
+            custom_settings=settings
         )
 
         test_string = self.read_test_file(self.processor_name, 'alignment_true.md')
@@ -242,14 +248,16 @@ class BlockquoteTest(ProcessorTest):
     def test_custom_arguments_alignment_true_missing_argument(self):
         '''Tests to ensure that blockquote tag raises errors when alignment argument is required and not given.
         '''
-        custom_argument_rules = {
-            "blockquote": {
-                "alignment": True
+        settings = {
+            'processor_argument_overrides': {
+                'blockquote': {
+                    'alignment': True
+                }
             }
         }
         verto_extension_custom_rules = VertoExtension(
             processors=[self.processor_name],
-            custom_argument_rules=custom_argument_rules
+            custom_settings=settings
         )
 
         test_string = self.read_test_file(self.processor_name, 'alignment_true_missing_argument.md')
diff --git a/verto/tests/BoxedTextTest.py b/verto/tests/BoxedTextTest.py
index 258afeb..5fb2556 100644
--- a/verto/tests/BoxedTextTest.py
+++ b/verto/tests/BoxedTextTest.py
@@ -123,15 +123,16 @@ class BoxedTextTest(ProcessorTest):
     def test_custom_arguments_indented_required(self):
         '''Tests to ensure that boxed text tag is rendered correctly when indented argument is required.
         '''
-        custom_argument_rules = {
-            "boxed-text": {
-                "indented": True
+        settings = {
+            'processor_argument_overrides': {
+                'boxed-text': {
+                    'indented': True,
+                }
             }
         }
-
         verto_extension_custom_rules = VertoExtension(
             processors=[self.processor_name],
-            custom_argument_rules=custom_argument_rules
+            custom_settings=settings
         )
 
         test_string = self.read_test_file(self.processor_name, 'indented_required.md')
@@ -146,14 +147,16 @@ class BoxedTextTest(ProcessorTest):
     def test_custom_arguments_type_required(self):
         '''Tests to ensure that boxed text tag is rendered correctly when type argument is required.
         '''
-        custom_argument_rules = {
-            "boxed-text": {
-                "type": True
+        settings = {
+            'processor_argument_overrides': {
+                'boxed-text': {
+                    'type': True,
+                }
             }
         }
         verto_extension_custom_rules = VertoExtension(
             processors=[self.processor_name],
-            custom_argument_rules=custom_argument_rules
+            custom_settings=settings
         )
 
         test_string = self.read_test_file(self.processor_name, 'type_required.md')
@@ -168,15 +171,17 @@ class BoxedTextTest(ProcessorTest):
     def test_custom_arguments_indented_and_type_required(self):
         '''Tests to ensure that boxed text tag is rendered correctly when both indented and type arguments are required.
         '''
-        custom_argument_rules = {
-            "boxed-text": {
-                "indented": True,
-                "type": True
+        settings = {
+            'processor_argument_overrides': {
+                'boxed-text': {
+                    'indented': True,
+                    'type': True,
+                }
             }
         }
         verto_extension_custom_rules = VertoExtension(
             processors=[self.processor_name],
-            custom_argument_rules=custom_argument_rules
+            custom_settings=settings
         )
 
         test_string = self.read_test_file(self.processor_name, 'indented_and_type_required.md')
@@ -191,14 +196,16 @@ class BoxedTextTest(ProcessorTest):
     def test_custom_arguments_indented_required_not_provided(self):
         '''Tests to ensure that error is raised when indented argument is required and not given.
         '''
-        custom_argument_rules = {
-            "boxed-text": {
-                "indented": True
+        settings = {
+            'processor_argument_overrides': {
+                'boxed-text': {
+                    'indented': True,
+                }
             }
         }
         verto_extension_custom_rules = VertoExtension(
             processors=[self.processor_name],
-            custom_argument_rules=custom_argument_rules
+            custom_settings=settings
         )
 
         test_string = self.read_test_file(self.processor_name, 'indented_required_not_provided.md')
@@ -211,15 +218,17 @@ class BoxedTextTest(ProcessorTest):
     def test_custom_arguments_indented_and_type_required_type_not_provided(self):
         '''Tests to ensure that error is raised when indented and type arguments are required and type is not given.
         '''
-        custom_argument_rules = {
-            "boxed-text": {
-                "indented": True,
-                "type": True
+        settings = {
+            'processor_argument_overrides': {
+                'boxed-text': {
+                    'indented': True,
+                    'type': True,
+                }
             }
         }
         verto_extension_custom_rules = VertoExtension(
             processors=[self.processor_name],
-            custom_argument_rules=custom_argument_rules
+            custom_settings=settings
         )
 
         test_string = self.read_test_file(self.processor_name, 'indented_and_type_required_type_not_provided.md')
diff --git a/verto/tests/ButtonLinkTest.py b/verto/tests/ButtonLinkTest.py
index dd46554..3b8302c 100644
--- a/verto/tests/ButtonLinkTest.py
+++ b/verto/tests/ButtonLinkTest.py
@@ -88,14 +88,16 @@ class ButtonLinkTest(ProcessorTest):
     def test_custom_arguments_link_false(self):
         '''Tests to ensure that button link tag is rendered correctly when link argument is required.
         '''
-        custom_argument_rules = {
-            "button-link": {
-                "link": False
+        settings = {
+            'processor_argument_overrides': {
+                'button-link': {
+                    'link': False,
+                }
             }
         }
         verto_extension_custom_rules = VertoExtension(
             processors=[self.processor_name],
-            custom_argument_rules=custom_argument_rules
+            custom_settings=settings
         )
 
         test_string = self.read_test_file(self.processor_name, 'link_false.md')
@@ -110,14 +112,16 @@ class ButtonLinkTest(ProcessorTest):
     def test_custom_arguments_text_false(self):
         '''Tests to ensure that button link tag is rendered correctly when text argument is false.
         '''
-        custom_argument_rules = {
-            "button-link": {
-                "text": False
+        settings = {
+            'processor_argument_overrides': {
+                'button-link': {
+                    'text': False,
+                }
             }
         }
         verto_extension_custom_rules = VertoExtension(
             processors=[self.processor_name],
-            custom_argument_rules=custom_argument_rules
+            custom_settings=settings
         )
 
         test_string = self.read_test_file(self.processor_name, 'text_false.md')
@@ -132,14 +136,16 @@ class ButtonLinkTest(ProcessorTest):
     def test_custom_arguments_file_true(self):
         '''Tests to ensure that button link tag is rendered correctly when file argument is true.
         '''
-        custom_argument_rules = {
-            "button-link": {
-                "file": True
+        settings = {
+            'processor_argument_overrides': {
+                'button-link': {
+                    'file': True,
+                }
             }
         }
         verto_extension_custom_rules = VertoExtension(
             processors=[self.processor_name],
-            custom_argument_rules=custom_argument_rules
+            custom_settings=settings
         )
 
         test_string = self.read_test_file(self.processor_name, 'file_true.md')
@@ -154,15 +160,17 @@ class ButtonLinkTest(ProcessorTest):
     def test_custom_arguments_text_false_file_true(self):
         '''Tests to ensure that button link tag is rendered correctly when text argument is false and file argument is true.
         '''
-        custom_argument_rules = {
-            "button-link": {
-                "file": True,
-                "text": False
+        settings = {
+            'processor_argument_overrides': {
+                'button-link': {
+                    'file': True,
+                    'text': False,
+                }
             }
         }
         verto_extension_custom_rules = VertoExtension(
             processors=[self.processor_name],
-            custom_argument_rules=custom_argument_rules
+            custom_settings=settings
         )
 
         test_string = self.read_test_file(self.processor_name, 'text_false_file_true.md')
@@ -177,14 +185,16 @@ class ButtonLinkTest(ProcessorTest):
     def test_custom_arguments_file_true_not_provided(self):
         '''Tests to ensure that error is raised when file argument is required and not given.
         '''
-        custom_argument_rules = {
-            "button-link": {
-                "file": True
+        settings = {
+            'processor_argument_overrides': {
+                'button-link': {
+                    'file': True,
+                }
             }
         }
         verto_extension_custom_rules = VertoExtension(
             processors=[self.processor_name],
-            custom_argument_rules=custom_argument_rules
+            custom_settings=settings
         )
 
         test_string = self.read_test_file(self.processor_name, 'file_true_not_provided.md')
diff --git a/verto/tests/ConfigurationTest.py b/verto/tests/ConfigurationTest.py
index e5b7639..53e89f1 100644
--- a/verto/tests/ConfigurationTest.py
+++ b/verto/tests/ConfigurationTest.py
@@ -369,27 +369,37 @@ class ConfigurationTest(BaseTest):
     def test_custom_arguments_rules_on_creation(self):
         '''Checks if tag arguments are updated.
         '''
-        custom_argument_rules = {
-            "image-tag": {
-                "alt": False
+        settings = {
+            'processor_argument_overrides': {
+                'image-tag': {
+                    'alt': False,
+                }
             }
         }
-        verto = Verto(custom_argument_rules=custom_argument_rules)
-        self.assertEqual(verto.verto_extension.custom_argument_rules, dict(custom_argument_rules))
+        verto = Verto(custom_settings=settings)
+        self.assertEqual(
+            verto.verto_extension.settings['processor_argument_overrides'],
+            dict(settings['processor_argument_overrides'])
+        )
 
     def test_custom_argument_rules_for_multiple_tags(self):
         '''Checks that md file is correctly parsed when multiple tags have custom argument rules.
         '''
-        custom_argument_rules = {
-            "image-tag": {
-                "alt": False
-            },
-            "panel": {
-                "subtitle": True
+        settings = {
+            'processor_argument_overrides': {
+                'image-tag': {
+                    'alt': False,
+                },
+                'panel': {
+                    'subtitle': True,
+                },
             }
         }
-        verto = Verto(custom_argument_rules=custom_argument_rules)
-        self.assertEqual(verto.verto_extension.custom_argument_rules, dict(custom_argument_rules))
+        verto = Verto(custom_settings=settings)
+        self.assertEqual(
+            verto.verto_extension.settings['processor_argument_overrides'],
+            dict(settings['processor_argument_overrides'])
+        )
         test_string = self.read_test_file(self.test_name, 'all_processors.md')
         converted_test_string = verto.convert(test_string).html_string
         expected_string = self.read_test_file(self.test_name, 'all_processors_expected.html', strip=True)
@@ -398,16 +408,18 @@ class ConfigurationTest(BaseTest):
     def test_custom_argument_rules_for_multiple_tags_error(self):
         '''Checks that error is raised when a tag's custom argument rules are not followed.
         '''
-        custom_argument_rules = {
-            "panel": {
-                "subtitle": True
-            },
-            "image-tag": {
-                "alt": False
+        settings = {
+            'processor_argument_overrides': {
+                'image-tag': {
+                    'alt': False,
+                },
+                'panel': {
+                    'subtitle': True,
+                }
             }
         }
         processors = {'image-tag', 'panel', 'comment'}
-        verto = VertoExtension(processors=processors, custom_argument_rules=custom_argument_rules)
+        verto = VertoExtension(processors=processors, custom_settings=settings)
 
         test_string = self.read_test_file(self.test_name, 'custom_argument_rules_multiple_tags_error.md')
         self.assertRaises(ArgumentMissingError, lambda x: markdown.markdown(x, extensions=[verto]), test_string)
@@ -415,29 +427,39 @@ class ConfigurationTest(BaseTest):
     def test_custom_argument_rules_incorrect_processor_error(self):
         '''Checks that error is raised when a processor given in custom argument rules does not exist.
         '''
-        custom_argument_rules = {
-            "panel": {
-                "totallyrealargument": True
-            },
-            "image-tag": {
-                "alt": False
+        settings = {
+            'processor_argument_overrides': {
+                'image-tag': {
+                    'alt': False,
+                },
+                'panel': {
+                    'totallyrealargument': True,
+                }
             }
         }
         processors = {'image-tag', 'panel', 'comment'}
 
-        self.assertRaises(CustomArgumentRulesError, lambda: VertoExtension(processors=processors, custom_argument_rules=custom_argument_rules))
+        self.assertRaises(
+            CustomArgumentRulesError,
+            lambda: VertoExtension(processors=processors, custom_settings=settings)
+        )
 
     def test_custom_argument_rules_incorrect_processor_argument_error(self):
         '''Checks that error is raised when a processor given in custom argument rules does not exist.
         '''
-        custom_argument_rules = {
-            "panl": {
-                "subtitle": True
-            },
-            "image-tag": {
-                "alt": False
+        settings = {
+            'processor_argument_overrides': {
+                'image-tag': {
+                    'alt': False,
+                },
+                'panl': {
+                    'subtitle': True,
+                }
             }
         }
         processors = {'image-tag', 'panel', 'comment'}
 
-        self.assertRaises(CustomArgumentRulesError, lambda: VertoExtension(processors=processors, custom_argument_rules=custom_argument_rules))
+        self.assertRaises(
+            CustomArgumentRulesError,
+            lambda: VertoExtension(processors=processors, custom_settings=settings)
+        )
diff --git a/verto/tests/FrameTest.py b/verto/tests/FrameTest.py
index 68aa283..561eb41 100644
--- a/verto/tests/FrameTest.py
+++ b/verto/tests/FrameTest.py
@@ -51,14 +51,16 @@ class FrameTest(ProcessorTest):
     def test_custom_argument_rules_link_false(self):
         '''Tests to ensure that iframe tag is rendered correctly when link argument is not required.
         '''
-        custom_argument_rules = {
-            "iframe": {
-                "link": False
+        settings = {
+            'processor_argument_overrides': {
+                'iframe': {
+                    'link': False
+                }
             }
         }
         verto_extension_custom_rules = VertoExtension(
             processors=[self.processor_name],
-            custom_argument_rules=custom_argument_rules
+            custom_settings=settings
         )
 
         test_string = self.read_test_file(self.processor_name, 'link_false.md')
diff --git a/verto/tests/GlossaryLinkTest.py b/verto/tests/GlossaryLinkTest.py
index 0e1100a..740228b 100644
--- a/verto/tests/GlossaryLinkTest.py
+++ b/verto/tests/GlossaryLinkTest.py
@@ -198,14 +198,16 @@ class GlossaryLinkTest(ProcessorTest):
     def test_custom_arguments_reference_text_true_not_provided(self):
         '''Tests to ensure that correct error is raised when reference text is required and not provided.
         '''
-        custom_argument_rules = {
-            "glossary-link": {
-                "reference-text": True
+        settings = {
+            'processor_argument_overrides': {
+                'glossary-link': {
+                    'reference-text': True
+                }
             }
         }
         verto_extension_custom_rules = VertoExtension(
             processors=[self.processor_name],
-            custom_argument_rules=custom_argument_rules
+            custom_settings=settings
         )
 
         test_string = self.read_test_file(self.processor_name, 'reference_text_true_not_provided.md')
diff --git a/verto/tests/ImageContainerTest.py b/verto/tests/ImageContainerTest.py
index e3e3cec..e61c784 100644
--- a/verto/tests/ImageContainerTest.py
+++ b/verto/tests/ImageContainerTest.py
@@ -451,14 +451,16 @@ class ImageContainerTest(ProcessorTest):
     def test_custom_arguments_alt_false(self):
         '''Tests to ensure that image tag is rendered correctly when alt tag is not required and expected images are updated.
         '''
-        custom_argument_rules = {
-            "image-container": {
-                "alt": False
+        settings = {
+            'processor_argument_overrides': {
+                'image-container': {
+                    'alt': False,
+                }
             }
         }
         verto_extension_custom_rules = VertoExtension(
             processors=[self.processor_name],
-            custom_argument_rules=custom_argument_rules
+            custom_settings=settings
         )
 
         test_string = self.read_test_file(self.processor_name, 'alt_false.md')
@@ -479,14 +481,16 @@ class ImageContainerTest(ProcessorTest):
     def test_custom_arguments_hover_true(self):
         '''Tests to ensure that image tag is rendered correctly when hover argument is required and expected images are updated.
         '''
-        custom_argument_rules = {
-            "image-container": {
-                "hover-text": True
+        settings = {
+            'processor_argument_overrides': {
+                'image-container': {
+                    'hover-text': True,
+                }
             }
         }
         verto_extension_custom_rules = VertoExtension(
             processors=[self.processor_name],
-            custom_argument_rules=custom_argument_rules
+            custom_settings=settings
         )
 
         test_string = self.read_test_file(self.processor_name, 'hover_true.md')
@@ -507,15 +511,17 @@ class ImageContainerTest(ProcessorTest):
     def test_custom_arguments_alt_false_source_true(self):
         '''Tests to ensure that image tag is rendered correctly when alt argument is not required and source argument is true and expected images are updated.
         '''
-        custom_argument_rules = {
-            "image-container": {
-                "alt": False,
-                "source": True
+        settings = {
+            'processor_argument_overrides': {
+                'image-container': {
+                    'alt': False,
+                    'source': True,
+                }
             }
         }
         verto_extension_custom_rules = VertoExtension(
             processors=[self.processor_name],
-            custom_argument_rules=custom_argument_rules
+            custom_settings=settings
         )
 
         test_string = self.read_test_file(self.processor_name, 'alt_false_source_true.md')
@@ -536,14 +542,16 @@ class ImageContainerTest(ProcessorTest):
     def test_custom_arguments_hover_true_not_provided(self):
         '''Tests to ensure that correct error is raised when hover text is required and not provided.
         '''
-        custom_argument_rules = {
-            "image-container": {
-                "hover-text": True
+        settings = {
+            'processor_argument_overrides': {
+                'image-container': {
+                    'hover-text': True,
+                }
             }
         }
         verto_extension_custom_rules = VertoExtension(
             processors=[self.processor_name],
-            custom_argument_rules=custom_argument_rules
+            custom_settings=settings
         )
 
         test_string = self.read_test_file(self.processor_name, 'hover_true_not_provided.md')
diff --git a/verto/tests/ImageInlineTest.py b/verto/tests/ImageInlineTest.py
index 0a2a759..827b649 100644
--- a/verto/tests/ImageInlineTest.py
+++ b/verto/tests/ImageInlineTest.py
@@ -324,14 +324,16 @@ class ImageInlineTest(ProcessorTest):
     def test_custom_arguments_alt_false(self):
         '''Tests to ensure that image tag is rendered correctly when alt tag is not required and expected images are updated.
         '''
-        custom_argument_rules = {
-            "image-inline": {
-                "alt": False
+        settings = {
+            'processor_argument_overrides': {
+                'image-inline': {
+                    'alt': False,
+                }
             }
         }
         verto_extension_custom_rules = VertoExtension(
             processors=[self.processor_name],
-            custom_argument_rules=custom_argument_rules
+            custom_settings=settings
         )
 
         test_string = self.read_test_file(self.processor_name, 'alt_false.md')
@@ -351,16 +353,19 @@ class ImageInlineTest(ProcessorTest):
     def test_custom_arguments_hover_true(self):
         '''Tests to ensure that image tag is rendered correctly when hover argument is required and expected images are updated.
         '''
-        custom_argument_rules = {
-            "image-inline": {
-                "hover-text": True
+        settings = {
+            'processor_argument_overrides': {
+                'image-inline': {
+                    'hover-text': True,
+                }
             }
         }
         verto_extension_custom_rules = VertoExtension(
             processors=[self.processor_name],
-            custom_argument_rules=custom_argument_rules
+            custom_settings=settings
         )
 
+
         test_string = self.read_test_file(self.processor_name, 'hover_true.md')
         processor = ImageInlinePattern(self.ext, self.md.parser)
         self.assertIsNotNone(re.search(processor.compiled_re, test_string))
@@ -378,15 +383,17 @@ class ImageInlineTest(ProcessorTest):
     def test_custom_arguments_alt_false_source_true(self):
         '''Tests to ensure that image tag is rendered correctly when alt argument is not required and source argument is required and expected images are updated.
         '''
-        custom_argument_rules = {
-            "image-inline": {
-                "alt": False,
-                "source": True
+        settings = {
+            'processor_argument_overrides': {
+                'image-inline': {
+                    'alt': False,
+                    'source': True,
+                }
             }
         }
         verto_extension_custom_rules = VertoExtension(
             processors=[self.processor_name],
-            custom_argument_rules=custom_argument_rules
+            custom_settings=settings
         )
 
         test_string = self.read_test_file(self.processor_name, 'alt_false_source_true.md')
@@ -406,14 +413,16 @@ class ImageInlineTest(ProcessorTest):
     def test_custom_arguments_hover_true_not_provided(self):
         '''Tests to ensure that correct error is raised when hover text is required and not provided.
         '''
-        custom_argument_rules = {
-            "image-inline": {
-                "hover-text": True
+        settings = {
+            'processor_argument_overrides': {
+                'image-inline': {
+                    'hover-text': True,
+                }
             }
         }
         verto_extension_custom_rules = VertoExtension(
             processors=[self.processor_name],
-            custom_argument_rules=custom_argument_rules
+            custom_settings=settings
         )
 
         test_string = self.read_test_file(self.processor_name, 'hover_true_not_provided.md')
diff --git a/verto/tests/ImageTagTest.py b/verto/tests/ImageTagTest.py
index ae01e45..ed0deb6 100644
--- a/verto/tests/ImageTagTest.py
+++ b/verto/tests/ImageTagTest.py
@@ -392,14 +392,16 @@ class ImageTagTest(ProcessorTest):
     def test_custom_arguments_alt_false(self):
         '''Tests to ensure that image tag is rendered correctly when alt tag is not required and expected images are updated.
         '''
-        custom_argument_rules = {
-            "image-tag": {
-                "alt": False
+        settings = {
+            'processor_argument_overrides': {
+                'image-tag': {
+                    'alt': False,
+                }
             }
         }
         verto_extension_custom_rules = VertoExtension(
             processors=[self.processor_name],
-            custom_argument_rules=custom_argument_rules
+            custom_settings=settings
         )
 
         test_string = self.read_test_file(self.processor_name, 'alt_false.md')
@@ -420,14 +422,16 @@ class ImageTagTest(ProcessorTest):
     def test_custom_arguments_hover_true(self):
         '''Tests to ensure that image tag is rendered correctly when hover argument is required and expected images are updated.
         '''
-        custom_argument_rules = {
-            "image-tag": {
-                "hover-text": True
+        settings = {
+            'processor_argument_overrides': {
+                'image-tag': {
+                    'hover-text': True,
+                }
             }
         }
         verto_extension_custom_rules = VertoExtension(
             processors=[self.processor_name],
-            custom_argument_rules=custom_argument_rules
+            custom_settings=settings
         )
 
         test_string = self.read_test_file(self.processor_name, 'hover_true.md')
@@ -448,15 +452,17 @@ class ImageTagTest(ProcessorTest):
     def test_custom_arguments_alt_false_source_true(self):
         '''Tests to ensure that image tag is rendered correctly when alt argument is not required and source argument is required and expected images are updated.
         '''
-        custom_argument_rules = {
-            "image-tag": {
-                "alt": False,
-                "source": True
+        settings = {
+            'processor_argument_overrides': {
+                'image-tag': {
+                    'alt': False,
+                    'source': True,
+                }
             }
         }
         verto_extension_custom_rules = VertoExtension(
             processors=[self.processor_name],
-            custom_argument_rules=custom_argument_rules
+            custom_settings=settings
         )
 
         test_string = self.read_test_file(self.processor_name, 'alt_false_source_true.md')
@@ -478,14 +484,16 @@ class ImageTagTest(ProcessorTest):
     def test_custom_arguments_hover_true_not_provided(self):
         '''Tests to ensure that correct error is raised when hover text is required and not provided.
         '''
-        custom_argument_rules = {
-            "image-tag": {
-                "hover-text": True
+        settings = {
+            'processor_argument_overrides': {
+                'image-tag': {
+                    'hover-text': True,
+                }
             }
         }
         verto_extension_custom_rules = VertoExtension(
             processors=[self.processor_name],
-            custom_argument_rules=custom_argument_rules
+            custom_settings=settings
         )
 
         test_string = self.read_test_file(self.processor_name, 'hover_true_not_provided.md')
diff --git a/verto/tests/InteractiveContainerTest.py b/verto/tests/InteractiveContainerTest.py
index 5516d78..f601afa 100644
--- a/verto/tests/InteractiveContainerTest.py
+++ b/verto/tests/InteractiveContainerTest.py
@@ -318,14 +318,16 @@ class InteractiveContainerTest(ProcessorTest):
     def test_custom_arguments_parameters_true(self):
         '''Tests to ensure that interactive tag is rendered correctly when parameters argument is not required.
         '''
-        custom_argument_rules = {
-            "interactive-container": {
-                "parameters": True
+        settings = {
+            'processor_argument_overrides': {
+                'interactive-container': {
+                    'parameters': True,
+                }
             }
         }
         verto_extension_custom_rules = VertoExtension(
             processors=[self.processor_name],
-            custom_argument_rules=custom_argument_rules
+            custom_settings=settings
         )
 
         test_string = self.read_test_file(self.processor_name, 'parameters_true.md')
@@ -340,14 +342,16 @@ class InteractiveContainerTest(ProcessorTest):
     def test_custom_arguments_thumbnail_true(self):
         '''Tests to ensure that interactive tag is rendered correctly when thumbnail argument is not required.
         '''
-        custom_argument_rules = {
-            "interactive-container": {
-                "thumbnail": True
+        settings = {
+            'processor_argument_overrides': {
+                'interactive-container': {
+                    'thumbnail': True,
+                }
             }
         }
         verto_extension_custom_rules = VertoExtension(
             processors=[self.processor_name],
-            custom_argument_rules=custom_argument_rules
+            custom_settings=settings
         )
 
         test_string = self.read_test_file(self.processor_name, 'thumbnail_true.md')
@@ -362,14 +366,16 @@ class InteractiveContainerTest(ProcessorTest):
     def test_custom_arguments_text_true_not_provided(self):
         '''Tests to ensure that correct error is raised when text is required and not provided.
         '''
-        custom_argument_rules = {
-            "interactive-container": {
-                "text": True
+        settings = {
+            'processor_argument_overrides': {
+                'interactive-container': {
+                    'text': True,
+                }
             }
         }
         verto_extension_custom_rules = VertoExtension(
             processors=[self.processor_name],
-            custom_argument_rules=custom_argument_rules
+            custom_settings=settings
         )
 
         test_string = self.read_test_file(self.processor_name, 'text_true_not_provided.md')
@@ -382,15 +388,17 @@ class InteractiveContainerTest(ProcessorTest):
     def test_custom_arguments_parameters_and_thumbnail_true(self):
         '''Tests to ensure that interactive tag is rendered correctly when text and thumbnail arguments are required.
         '''
-        custom_argument_rules = {
-            "interactive-container": {
-                "parameters": True,
-                "thumbnail": True
+        settings = {
+            'processor_argument_overrides': {
+                'interactive-container': {
+                    'parameters': True,
+                    'thumbnail': True,
+                }
             }
         }
         verto_extension_custom_rules = VertoExtension(
             processors=[self.processor_name],
-            custom_argument_rules=custom_argument_rules
+            custom_settings=settings
         )
 
         test_string = self.read_test_file(self.processor_name, 'parameters_and_thumbnail_true.md')
@@ -402,6 +410,58 @@ class InteractiveContainerTest(ProcessorTest):
         expected_string = self.read_test_file(self.processor_name, 'parameters_and_thumbnail_true_expected.html', strip=True)
         self.assertEqual(expected_string, converted_test_string)
 
+    def test_default_thumbnail_in_required_files(self):
+        '''Test the thumbnail for a whole page interactive is required.'''
+        verto_extension_default = VertoExtension(
+            processors=[self.processor_name],
+        )
+        test_string = self.read_test_file(self.processor_name, 'whole_page_without_thumbnail_parameter.md')
+        converted_test_string = markdown.markdown(test_string, extensions=[verto_extension_default])
+        self.assertEqual(
+            verto_extension_default.required_files['images'],
+            set(['interactives/binary-cards/img/thumbnail.png'])
+        )
+
+    def test_default_thumbnail_not_in_required_files_with_override(self):
+        '''Test the thumbnail for a whole page interactive is not required when overriden.'''
+        verto_extension_default_thumbnail_override = VertoExtension(
+            processors=[self.processor_name],
+            custom_settings={
+                'add_default_interactive_thumbnails_to_required_files': False}
+        )
+        test_string = self.read_test_file(self.processor_name, 'whole_page_without_thumbnail_parameter.md')
+        converted_test_string = markdown.markdown(test_string, extensions=[verto_extension_default_thumbnail_override])
+        self.assertEqual(
+            verto_extension_default_thumbnail_override.required_files['images'],
+            set()
+        )
+
+    def test_custom_thumbnail_in_required_files(self):
+        '''Test the custom thumbnail for a whole page interactive is required.'''
+        verto_extension_default = VertoExtension(
+            processors=[self.processor_name],
+        )
+        test_string = self.read_test_file(self.processor_name, 'whole_page_with_thumbnail_parameter.md')
+        converted_test_string = markdown.markdown(test_string, extensions=[verto_extension_default])
+        self.assertEqual(
+            verto_extension_default.required_files['images'],
+            set(['binarycards.png'])
+        )
+
+    def test_custom_thumbnail_not_in_required_files_with_override(self):
+        '''Test the custom thumbnail for a whole page interactive is not required when overriden.'''
+        verto_extension_custom_thumbnail_override = VertoExtension(
+            processors=[self.processor_name],
+            custom_settings={
+                'add_custom_interactive_thumbnails_to_required_files': False}
+        )
+        test_string = self.read_test_file(self.processor_name, 'whole_page_with_thumbnail_parameter.md')
+        converted_test_string = markdown.markdown(test_string, extensions=[verto_extension_custom_thumbnail_override])
+        self.assertEqual(
+            verto_extension_custom_thumbnail_override.required_files['images'],
+            set()
+        )
+
     # ~
     # Doc Tests
     # ~
diff --git a/verto/tests/InteractiveTagTest.py b/verto/tests/InteractiveTagTest.py
index 326b1d6..fc5e5b5 100644
--- a/verto/tests/InteractiveTagTest.py
+++ b/verto/tests/InteractiveTagTest.py
@@ -129,17 +129,69 @@ class InteractiveTagTest(ProcessorTest):
         }
         self.assertEqual(self.verto_extension.required_files, required_files)
 
+    def test_default_thumbnail_in_required_files(self):
+        '''Test the thumbnail for a whole page interactive is required.'''
+        verto_extension_default = VertoExtension(
+            processors=[self.processor_name],
+        )
+        test_string = self.read_test_file(self.processor_name, 'whole_page_without_thumbnail_parameter.md')
+        converted_test_string = markdown.markdown(test_string, extensions=[verto_extension_default])
+        self.assertEqual(
+            verto_extension_default.required_files['images'],
+            set(['interactives/binary-cards/img/thumbnail.png'])
+        )
+
+    def test_default_thumbnail_not_in_required_files_with_override(self):
+        '''Test the thumbnail for a whole page interactive is not required when overriden.'''
+        verto_extension_default_thumbnail_override = VertoExtension(
+            processors=[self.processor_name],
+            custom_settings={'add_default_interactive_thumbnails_to_required_files': False}
+        )
+        test_string = self.read_test_file(self.processor_name, 'whole_page_without_thumbnail_parameter.md')
+        converted_test_string = markdown.markdown(test_string, extensions=[verto_extension_default_thumbnail_override])
+        self.assertEqual(
+            verto_extension_default_thumbnail_override.required_files['images'],
+            set()
+        )
+
+    def test_custom_thumbnail_in_required_files(self):
+        '''Test the custom thumbnail for a whole page interactive is required.'''
+        verto_extension_default = VertoExtension(
+            processors=[self.processor_name],
+        )
+        test_string = self.read_test_file(self.processor_name, 'whole_page_with_thumbnail_parameter.md')
+        converted_test_string = markdown.markdown(test_string, extensions=[verto_extension_default])
+        self.assertEqual(
+            verto_extension_default.required_files['images'],
+            set(['binarycards.png'])
+        )
+
+    def test_custom_thumbnail_not_in_required_files_with_override(self):
+        '''Test the custom thumbnail for a whole page interactive is not required when overriden.'''
+        verto_extension_custom_thumbnail_override = VertoExtension(
+            processors=[self.processor_name],
+            custom_settings={'add_custom_interactive_thumbnails_to_required_files': False}
+        )
+        test_string = self.read_test_file(self.processor_name, 'whole_page_with_thumbnail_parameter.md')
+        converted_test_string = markdown.markdown(test_string, extensions=[verto_extension_custom_thumbnail_override])
+        self.assertEqual(
+            verto_extension_custom_thumbnail_override.required_files['images'],
+            set()
+        )
+
     def test_custom_arguments_parameters_true(self):
         '''Tests to ensure that interactive tag is rendered correctly when parameters argument is required.
         '''
-        custom_argument_rules = {
-            "interactive-tag": {
-                "parameters": True
+        settings = {
+            'processor_argument_overrides': {
+                'interactive-tag': {
+                    'parameters': True
+                }
             }
         }
         verto_extension_custom_rules = VertoExtension(
             processors=[self.processor_name],
-            custom_argument_rules=custom_argument_rules
+            custom_settings=settings
         )
 
         test_string = self.read_test_file(self.processor_name, 'parameters_true.md')
@@ -154,16 +206,19 @@ class InteractiveTagTest(ProcessorTest):
     def test_custom_arguments_thumbnail_true(self):
         '''Tests to ensure that interactive tag is rendered correctly when thumbnail argument is required.
         '''
-        custom_argument_rules = {
-            "interactive-tag": {
-                "thumbnail": True
+        settings = {
+            'processor_argument_overrides': {
+                'interactive-tag': {
+                    'thumbnail': True
+                }
             }
         }
         verto_extension_custom_rules = VertoExtension(
             processors=[self.processor_name],
-            custom_argument_rules=custom_argument_rules
+            custom_settings=settings
         )
 
+
         test_string = self.read_test_file(self.processor_name, 'thumbnail_true.md')
         blocks = self.to_blocks(test_string)
 
@@ -176,15 +231,17 @@ class InteractiveTagTest(ProcessorTest):
     def test_custom_arguments_parameters_and_thumbnail_true(self):
         '''Tests to ensure that interactive tag is rendered correctly when type argument is not required and parameters argument is required.
         '''
-        custom_argument_rules = {
-            "interactive-tag": {
-                "parameters": True,
-                "thumbnail": True
+        settings = {
+            'processor_argument_overrides': {
+                'interactive-tag': {
+                    'parameters': True,
+                    'thumbnail': True
+                }
             }
         }
         verto_extension_custom_rules = VertoExtension(
             processors=[self.processor_name],
-            custom_argument_rules=custom_argument_rules
+            custom_settings=settings
         )
 
         test_string = self.read_test_file(self.processor_name, 'parameters_and_thumbnail_true.md')
diff --git a/verto/tests/PanelTest.py b/verto/tests/PanelTest.py
index 4151d02..6463ee6 100644
--- a/verto/tests/PanelTest.py
+++ b/verto/tests/PanelTest.py
@@ -371,14 +371,16 @@ class PanelTest(ProcessorTest):
     def test_custom_arguments_type_false(self):
         '''Tests to ensure that panel tag is rendered correctly when type argument is not required.
         '''
-        custom_argument_rules = {
-            "panel": {
-                "type": False
+        settings = {
+            'processor_argument_overrides': {
+                'panel': {
+                    'type': False
+                }
             }
         }
         verto_extension_custom_rules = VertoExtension(
             processors=[self.processor_name],
-            custom_argument_rules=custom_argument_rules
+            custom_settings=settings
         )
 
         test_string = self.read_test_file(self.processor_name, 'type_false.md')
@@ -393,14 +395,16 @@ class PanelTest(ProcessorTest):
     def test_custom_arguments_subtitle_true(self):
         '''Tests to ensure that panel tag is rendered correctly when subtitle argument is required.
         '''
-        custom_argument_rules = {
-            "panel": {
-                "subtitle": True
+        settings = {
+            'processor_argument_overrides': {
+                'panel': {
+                    'subtitle': True
+                }
             }
         }
         verto_extension_custom_rules = VertoExtension(
             processors=[self.processor_name],
-            custom_argument_rules=custom_argument_rules
+            custom_settings=settings
         )
 
         test_string = self.read_test_file(self.processor_name, 'subtitle_true.md')
@@ -415,14 +419,16 @@ class PanelTest(ProcessorTest):
     def test_custom_arguments_expanded_true(self):
         '''Tests to ensure that panel tag is rendered correctly when expanded argument is required.
         '''
-        custom_argument_rules = {
-            "panel": {
-                "expanded": True
+        settings = {
+            'processor_argument_overrides': {
+                'panel': {
+                    'expanded': True
+                }
             }
         }
         verto_extension_custom_rules = VertoExtension(
             processors=[self.processor_name],
-            custom_argument_rules=custom_argument_rules
+            custom_settings=settings
         )
 
         test_string = self.read_test_file(self.processor_name, 'expanded_true.md')
@@ -437,14 +443,16 @@ class PanelTest(ProcessorTest):
     def test_custom_arguments_subtitle_true_not_provided(self):
         '''Tests to ensure that correct error is raised when subtitle is required and not provided.
         '''
-        custom_argument_rules = {
-            "panel": {
-                "subtitle": True
+        settings = {
+            'processor_argument_overrides': {
+                'panel': {
+                    'subtitle': True
+                }
             }
         }
         verto_extension_custom_rules = VertoExtension(
             processors=[self.processor_name],
-            custom_argument_rules=custom_argument_rules
+            custom_settings=settings
         )
 
         test_string = self.read_test_file(self.processor_name, 'subtitle_true_not_provided.md')
diff --git a/verto/tests/VideoTest.py b/verto/tests/VideoTest.py
index 8c499fc..426c167 100644
--- a/verto/tests/VideoTest.py
+++ b/verto/tests/VideoTest.py
@@ -189,14 +189,16 @@ class VideoTest(ProcessorTest):
     def test_url_false_custom_argument_rules(self):
         '''Tests to ensure that video tag is rendered correctly when url argument is not required.
         '''
-        custom_argument_rules = {
-            "video": {
-                "url": False
+        settings = {
+            'processor_argument_overrides': {
+                'video': {
+                    'url': False
+                }
             }
         }
         verto_extension_custom_rules = VertoExtension(
             processors=[self.processor_name],
-            custom_argument_rules=custom_argument_rules
+            custom_settings=settings
         )
 
         test_string = self.read_test_file(self.processor_name, 'url_false.md')
@@ -211,14 +213,16 @@ class VideoTest(ProcessorTest):
     def test_custom_argument_rules_title_true_not_provided(self):
         '''Tests to ensure that error is raised when title argument is required but not provided.
         '''
-        custom_argument_rules = {
-            "video": {
-                "title": True
+        settings = {
+            'processor_argument_overrides': {
+                'video': {
+                    'title': True
+                }
             }
         }
         verto_extension_custom_rules = VertoExtension(
             processors=[self.processor_name],
-            custom_argument_rules=custom_argument_rules
+            custom_settings=settings
         )
 
         test_string = self.read_test_file(self.processor_name, 'title_true_not_provided.md')
diff --git a/verto/tests/assets/interactive-container/whole_page_with_thumbnail_parameter.md b/verto/tests/assets/interactive-container/whole_page_with_thumbnail_parameter.md
new file mode 100644
index 0000000..39d7a20
--- /dev/null
+++ b/verto/tests/assets/interactive-container/whole_page_with_thumbnail_parameter.md
@@ -0,0 +1,5 @@
+{interactive slug="binary-cards" type="whole-page" thumbnail="binarycards.png" text="true"}
+
+There is an indentation in the shape of you
+
+{interactive end}
diff --git a/verto/tests/assets/interactive-container/whole_page_without_thumbnail_parameter.md b/verto/tests/assets/interactive-container/whole_page_without_thumbnail_parameter.md
new file mode 100644
index 0000000..35ce07c
--- /dev/null
+++ b/verto/tests/assets/interactive-container/whole_page_without_thumbnail_parameter.md
@@ -0,0 +1,5 @@
+{interactive slug="binary-cards" type="whole-page" text="true"}
+
+There is an indentation in the shape of you
+
+{interactive end}
diff --git a/verto/tests/assets/interactive-tag/whole_page_with_thumbnail_parameter.md b/verto/tests/assets/interactive-tag/whole_page_with_thumbnail_parameter.md
new file mode 100644
index 0000000..61b195e
--- /dev/null
+++ b/verto/tests/assets/interactive-tag/whole_page_with_thumbnail_parameter.md
@@ -0,0 +1,1 @@
+{interactive slug="binary-cards" type="whole-page" thumbnail="binarycards.png"}
diff --git a/verto/tests/assets/interactive-tag/whole_page_without_thumbnail_parameter.md b/verto/tests/assets/interactive-tag/whole_page_without_thumbnail_parameter.md
new file mode 100644
index 0000000..4d6974b
--- /dev/null
+++ b/verto/tests/assets/interactive-tag/whole_page_without_thumbnail_parameter.md
@@ -0,0 +1,1 @@
+{interactive slug="binary-cards" type="whole-page"}