Fix RSS watch titles

.dockerignore

@@ -33,6 +33,7 @@ venv/
 # Test and development files
 test-datastore/
 tests/
+docs/
 *.md
 !README.md
 

.github/dependabot.yml

@@ -4,11 +4,11 @@ updates:
     directory: /
     schedule:
       interval: "weekly"
+    "caronc/apprise":
+      versioning-strategy: "increase"
+      schedule:
+        interval: "daily"
     groups:
       all:
         patterns:
         - "*"
-  - package-ecosystem: pip
-    directory: /
-    schedule:
-      interval: "weekly"

.github/workflows/codeql-analysis.yml

@@ -34,7 +34,7 @@ jobs:
 
     # Initializes the CodeQL tools for scanning.
     - name: Initialize CodeQL
-      uses: github/codeql-action/init@v4
+      uses: github/codeql-action/init@v3
       with:
         languages: ${{ matrix.language }}
         # If you wish to specify custom queries, you can do so here or in a config file.
@@ -45,7 +45,7 @@ jobs:
     # Autobuild attempts to build any compiled languages  (C/C++, C#, or Java).
     # If this step fails, then you should remove it and run the build manually (see below)
     - name: Autobuild
-      uses: github/codeql-action/autobuild@v4
+      uses: github/codeql-action/autobuild@v3
 
     # ℹ️ Command-line programs to run using the OS shell.
     # 📚 https://git.io/JvXDl
@@ -59,4 +59,4 @@ jobs:
     #   make release
 
     - name: Perform CodeQL Analysis
-      uses: github/codeql-action/analyze@v4
+      uses: github/codeql-action/analyze@v3

.github/workflows/containers.yml

@@ -95,7 +95,7 @@ jobs:
           push: true
           tags: |
             ${{ secrets.DOCKER_HUB_USERNAME }}/changedetection.io:dev,ghcr.io/${{ github.repository }}:dev
-          platforms: linux/amd64,linux/arm64,linux/arm/v7,linux/arm/v8
+          platforms: linux/amd64,linux/arm64,linux/arm/v7,linux/arm/v8,linux/arm64/v8
           cache-from: type=gha
           cache-to: type=gha,mode=max
 
@@ -133,7 +133,7 @@ jobs:
           file: ./Dockerfile
           push: true
           tags: ${{ steps.meta.outputs.tags }}
-          platforms: linux/amd64,linux/arm64,linux/arm/v7,linux/arm/v8
+          platforms: linux/amd64,linux/arm64,linux/arm/v7,linux/arm/v8,linux/arm64/v8
           cache-from: type=gha
           cache-to: type=gha,mode=max
 # Looks like this was disabled

.github/workflows/test-container-build.yml

@@ -38,6 +38,8 @@ jobs:
             dockerfile: ./Dockerfile
           - platform: linux/arm/v8
             dockerfile: ./Dockerfile
+          - platform: linux/arm64/v8
+            dockerfile: ./Dockerfile
           # Alpine Dockerfile platforms (musl via alpine check)
           - platform: linux/amd64
             dockerfile: ./.github/test/Dockerfile-alpine
@@ -74,5 +76,5 @@ jobs:
             file: ${{ matrix.dockerfile }}
             platforms: ${{ matrix.platform }}
             cache-from: type=gha
-            cache-to: type=gha,mode=min
+            cache-to: type=gha,mode=max
 

Dockerfile

@@ -84,11 +84,6 @@ EXPOSE 5000
 
 # The actual flask app module
 COPY changedetectionio /app/changedetectionio
-
-# Also for OpenAPI validation wrapper - needs the YML
-RUN [ ! -d "/app/docs" ] && mkdir /app/docs
-COPY docs/api-spec.yaml /app/docs/api-spec.yaml
-
 # Starting wrapper
 COPY changedetection.py /app/changedetection.py
 

changedetectionio/__init__.py

@@ -2,7 +2,7 @@
 
 # Read more https://github.com/dgtlmoon/changedetection.io/wiki
 
-__version__ = '0.50.20'
+__version__ = '0.50.12'
 
 from changedetectionio.strtobool import strtobool
 from json.decoder import JSONDecodeError

changedetectionio/api/Watch.py

@@ -14,39 +14,6 @@ import copy
 from . import schema, schema_create_watch, schema_update_watch, validate_openapi_request
 
 
-def validate_time_between_check_required(json_data):
-    """
-    Validate that at least one time interval is specified when not using default settings.
-    Returns None if valid, or error message string if invalid.
-    Defaults to using global settings if time_between_check_use_default is not provided.
-    """
-    # Default to using global settings if not specified
-    use_default = json_data.get('time_between_check_use_default', True)
-
-    # If using default settings, no validation needed
-    if use_default:
-        return None
-
-    # If not using defaults, check if time_between_check exists and has at least one non-zero value
-    time_check = json_data.get('time_between_check')
-    if not time_check:
-        # No time_between_check provided and not using defaults - this is an error
-        return "At least one time interval (weeks, days, hours, minutes, or seconds) must be specified when not using global settings."
-
-    # time_between_check exists, check if it has at least one non-zero value
-    if any([
-        (time_check.get('weeks') or 0) > 0,
-        (time_check.get('days') or 0) > 0,
-        (time_check.get('hours') or 0) > 0,
-        (time_check.get('minutes') or 0) > 0,
-        (time_check.get('seconds') or 0) > 0
-    ]):
-        return None
-
-    # time_between_check exists but all values are 0 or empty - this is an error
-    return "At least one time interval (weeks, days, hours, minutes, or seconds) must be specified when not using global settings."
-
-
 class Watch(Resource):
     def __init__(self, **kwargs):
         # datastore is a black box dependency
@@ -88,8 +55,6 @@ class Watch(Resource):
         # attr .last_changed will check for the last written text snapshot on change
         watch['last_changed'] = watch.last_changed
         watch['viewed'] = watch.viewed
-        watch['link'] = watch.link,
-
         return watch
 
     @auth.check_token
@@ -116,11 +81,6 @@ class Watch(Resource):
             if not request.json.get('proxy') in plist:
                 return "Invalid proxy choice, currently supported proxies are '{}'".format(', '.join(plist)), 400
 
-        # Validate time_between_check when not using defaults
-        validation_error = validate_time_between_check_required(request.json)
-        if validation_error:
-            return validation_error, 400
-
         watch.update(request.json)
 
         return "OK", 200
@@ -236,11 +196,6 @@ class CreateWatch(Resource):
             if not json_data.get('proxy') in plist:
                 return "Invalid proxy choice, currently supported proxies are '{}'".format(', '.join(plist)), 400
 
-        # Validate time_between_check when not using defaults
-        validation_error = validate_time_between_check_required(json_data)
-        if validation_error:
-            return validation_error, 400
-
         extras = copy.deepcopy(json_data)
 
         # Because we renamed 'tag' to 'tags' but don't want to change the API (can do this in v2 of the API)
@@ -275,8 +230,6 @@ class CreateWatch(Resource):
                 'last_changed': watch.last_changed,
                 'last_checked': watch['last_checked'],
                 'last_error': watch['last_error'],
-                'link': watch.link,
-                'page_title': watch['page_title'],
                 'title': watch['title'],
                 'url': watch['url'],
                 'viewed': watch.viewed

changedetectionio/api/__init__.py

@@ -1,7 +1,9 @@
 import copy
+import yaml
 import functools
 from flask import request, abort
-from loguru import logger
+from openapi_core import OpenAPI
+from openapi_core.contrib.flask import FlaskOpenAPIRequest
 from . import api_schema
 from ..model import watch_base
 
@@ -29,17 +31,17 @@ schema_create_notification_urls['required'] = ['notification_urls']
 schema_delete_notification_urls = copy.deepcopy(schema_notification_urls)
 schema_delete_notification_urls['required'] = ['notification_urls']
 
-@functools.cache
-def get_openapi_spec():
-    """Lazy load OpenAPI spec and dependencies only when validation is needed."""
-    import os
-    import yaml  # Lazy import - only loaded when API validation is actually used
-    from openapi_core import OpenAPI  # Lazy import - saves ~10.7 MB on startup
+# Load OpenAPI spec for validation
+_openapi_spec = None
 
-    spec_path = os.path.join(os.path.dirname(__file__), '../../docs/api-spec.yaml')
-    with open(spec_path, 'r') as f:
-        spec_dict = yaml.safe_load(f)
-    _openapi_spec = OpenAPI.from_dict(spec_dict)
+def get_openapi_spec():
+    global _openapi_spec
+    if _openapi_spec is None:
+        import os
+        spec_path = os.path.join(os.path.dirname(__file__), '../../docs/api-spec.yaml')
+        with open(spec_path, 'r') as f:
+            spec_dict = yaml.safe_load(f)
+        _openapi_spec = OpenAPI.from_dict(spec_dict)
     return _openapi_spec
 
 def validate_openapi_request(operation_id):
@@ -48,28 +50,16 @@ def validate_openapi_request(operation_id):
         @functools.wraps(f)
         def wrapper(*args, **kwargs):
             try:
-                # Skip OpenAPI validation for GET requests since they don't have request bodies
-                if request.method.upper() != 'GET':
-                    # Lazy import - only loaded when actually validating a request
-                    from openapi_core.contrib.flask import FlaskOpenAPIRequest
-
-                    spec = get_openapi_spec()
-                    openapi_request = FlaskOpenAPIRequest(request)
-                    result = spec.unmarshal_request(openapi_request)
-                    if result.errors:
-                        from werkzeug.exceptions import BadRequest
-                        error_details = []
-                        for error in result.errors:
-                            error_details.append(str(error))
-                        raise BadRequest(f"OpenAPI validation failed: {error_details}")
-            except BadRequest:
-                # Re-raise BadRequest exceptions (validation failures)
-                raise
+                spec = get_openapi_spec()
+                openapi_request = FlaskOpenAPIRequest(request)
+                result = spec.unmarshal_request(openapi_request)
+                if result.errors:
+                    abort(400, message=f"OpenAPI validation failed: {result.errors}")
+                return f(*args, **kwargs)
             except Exception as e:
-                # If OpenAPI spec loading fails, log but don't break existing functionality
-                logger.critical(f"OpenAPI validation warning for {operation_id}: {e}")
-                abort(500)
-            return f(*args, **kwargs)
+                # If OpenAPI validation fails, log but don't break existing functionality
+                print(f"OpenAPI validation warning for {operation_id}: {e}")
+                return f(*args, **kwargs)
         return wrapper
     return decorator
 
@@ -79,4 +69,3 @@ from .Tags import Tags, Tag
 from .Import import Import
 from .SystemInfo import SystemInfo
 from .Notifications import Notifications
-

changedetectionio/api/api_schema.py

@@ -119,12 +119,6 @@ def build_watch_json_schema(d):
 
     schema['properties']['time_between_check'] = build_time_between_check_json_schema()
 
-    schema['properties']['time_between_check_use_default'] = {
-        "type": "boolean",
-        "default": True,
-        "description": "Whether to use global settings for time between checks - defaults to true if not set"
-    }
-
     schema['properties']['browser_steps'] = {
         "anyOf": [
             {

changedetectionio/blueprint/settings/templates/settings.html

@@ -191,12 +191,6 @@ nav
                         </ul>
                      </span>
                     </fieldset>
-                    <fieldset class="pure-group">
-                        {{ render_checkbox_field(form.application.form.strip_ignored_lines) }}
-                        <span class="pure-form-message-inline">Remove any text that appears in the "Ignore text" from the output (otherwise its just ignored for change-detection)<br>
-                        <i>Note:</i> Changing this will change the status of your existing watches, possibly trigger alerts etc.
-                        </span>
-                    </fieldset>
            </div>
 
             <div class="tab-pane-inner" id="api">

changedetectionio/blueprint/ui/edit.py

@@ -242,7 +242,6 @@ def construct_blueprint(datastore: ChangeDetectionStore, update_q, queuedWatchMe
                 'available_timezones': sorted(available_timezones()),
                 'browser_steps_config': browser_step_ui_config,
                 'emailprefix': os.getenv('NOTIFICATION_MAIL_BUTTON_PREFIX', False),
-                'extra_classes': 'checking-now' if worker_handler.is_watch_running(uuid) else '',
                 'extra_notification_token_placeholder_info': datastore.get_unique_notification_token_placeholders_available(),
                 'extra_processor_config': form.extra_tab_content(),
                 'extra_title': f" - Edit - {watch.label}",

changedetectionio/blueprint/watchlist/__init__.py

@@ -87,6 +87,7 @@ def construct_blueprint(datastore: ChangeDetectionStore, update_q, queuedWatchMe
             form=form,
             guid=datastore.data['app_guid'],
             has_proxies=datastore.proxy_list,
+            has_unviewed=datastore.has_unviewed,
             hosted_sticky=os.getenv("SALTED_PASS", False) == False,
             now_time_server=round(time.time()),
             pagination=pagination,
@@ -96,7 +97,6 @@ def construct_blueprint(datastore: ChangeDetectionStore, update_q, queuedWatchMe
             sort_order=request.args.get('order') if request.args.get('order') else request.cookies.get('order'),
             system_default_fetcher=datastore.data['settings']['application'].get('fetch_backend'),
             tags=sorted_tags,
-            unread_changes_count=datastore.unread_changes_count,
             watches=sorted_watches
         )
 

changedetectionio/blueprint/watchlist/templates/watch-overview.html

@@ -82,11 +82,8 @@ document.addEventListener('DOMContentLoaded', function() {
         {%- set cols_required = cols_required + 1 -%}
     {%- endif -%}
     {%- set ui_settings = datastore.data['settings']['application']['ui'] -%}
-    {%- set wrapper_classes = [
-        'has-unread-changes' if unread_changes_count else '',
-        'has-error' if errored_count else '',
-    ] -%}
-    <div id="watch-table-wrapper" class="{{ wrapper_classes | reject('equalto', '') | join(' ') }}">
+
+    <div id="watch-table-wrapper">
         {%- set table_classes = [
             'favicon-enabled' if 'favicons_enabled' not in ui_settings or ui_settings['favicons_enabled'] else 'favicon-not-enabled',
         ] -%}
@@ -161,9 +158,9 @@ document.addEventListener('DOMContentLoaded', function() {
                         <div>
                         <span class="watch-title">
                             {% if system_use_url_watchlist or watch.get('use_page_title_in_list') %}
-                                {{ watch.label }}
+                                {{watch.label}}
                             {% else %}
-                                {{ watch.get('title') or watch.link }}
+                                {{watch.url}}
                             {% endif %}
                            <a class="external" target="_blank" rel="noopener" href="{{ watch.link.replace('source:','') }}">&nbsp;</a>
                         </span>
@@ -244,10 +241,10 @@ document.addEventListener('DOMContentLoaded', function() {
             </tbody>
         </table>
         <ul id="post-list-buttons">
-            <li id="post-list-with-errors" style="display: none;" >
+            <li id="post-list-with-errors" class="{%- if errored_count -%}has-error{%- endif -%}" style="display: none;" >
                 <a href="{{url_for('watchlist.index', with_errors=1, tag=request.args.get('tag')) }}" class="pure-button button-tag button-error">With errors ({{ errored_count }})</a>
             </li>
-            <li id="post-list-mark-views" style="display: none;" >
+            <li id="post-list-mark-views" class="{%- if has_unviewed -%}has-unviewed{%- endif -%}" style="display: none;" >
                 <a href="{{url_for('ui.mark_all_viewed',with_errors=request.args.get('with_errors',0)) }}" class="pure-button button-tag " id="mark-all-viewed">Mark all viewed</a>
             </li>
         {%-  if active_tag_uuid -%}
@@ -255,8 +252,8 @@ document.addEventListener('DOMContentLoaded', function() {
                 <a href="{{url_for('ui.mark_all_viewed', tag=active_tag_uuid) }}" class="pure-button button-tag " id="mark-all-viewed">Mark all viewed in '{{active_tag.title}}'</a>
             </li>
         {%-  endif -%}
-            <li id="post-list-unread" style="display: none;" >
-                <a href="{{url_for('watchlist.index', unread=1, tag=request.args.get('tag')) }}" class="pure-button button-tag">Unread (<span id="unread-tab-counter">{{ unread_changes_count }}</span>)</a>
+            <li id="post-list-unread" class="{%- if has_unviewed -%}has-unviewed{%- endif -%}" style="display: none;" >
+                <a href="{{url_for('watchlist.index', unread=1, tag=request.args.get('tag')) }}" class="pure-button button-tag">Unread</a>
             </li>
             <li>
                <a href="{{ url_for('ui.form_watch_checknow', tag=active_tag_uuid, with_errors=request.args.get('with_errors',0)) }}" class="pure-button button-tag" id="recheck-all">Recheck

changedetectionio/forms.py

@@ -23,7 +23,6 @@ from wtforms import (
 )
 from flask_wtf.file import FileField, FileAllowed
 from wtforms.fields import FieldList
-from wtforms.utils import unset_value
 
 from wtforms.validators import ValidationError
 
@@ -57,8 +56,6 @@ valid_method = {
 
 default_method = 'GET'
 allow_simplehost = not strtobool(os.getenv('BLOCK_SIMPLEHOSTS', 'False'))
-REQUIRE_ATLEAST_ONE_TIME_PART_MESSAGE_DEFAULT='At least one time interval (weeks, days, hours, minutes, or seconds) must be specified.'
-REQUIRE_ATLEAST_ONE_TIME_PART_WHEN_NOT_GLOBAL_DEFAULT='At least one time interval (weeks, days, hours, minutes, or seconds) must be specified when not using global settings.'
 
 class StringListField(StringField):
     widget = widgets.TextArea()
@@ -215,35 +212,6 @@ class ScheduleLimitForm(Form):
         self.sunday.form.enabled.label.text = "Sunday"
 
 
-def validate_time_between_check_has_values(form):
-    """
-    Custom validation function for TimeBetweenCheckForm.
-    Returns True if at least one time interval field has a value > 0.
-    """
-    res = any([
-        form.weeks.data and int(form.weeks.data) > 0,
-        form.days.data and int(form.days.data) > 0,
-        form.hours.data and int(form.hours.data) > 0,
-        form.minutes.data and int(form.minutes.data) > 0,
-        form.seconds.data and int(form.seconds.data) > 0
-    ])
-
-    return res
-
-
-class RequiredTimeInterval(object):
-    """
-    WTForms validator that ensures at least one time interval field has a value > 0.
-    Use this with FormField(TimeBetweenCheckForm, validators=[RequiredTimeInterval()]).
-    """
-    def __init__(self, message=None):
-        self.message = message or 'At least one time interval (weeks, days, hours, minutes, or seconds) must be specified.'
-
-    def __call__(self, form, field):
-        if not validate_time_between_check_has_values(field.form):
-            raise ValidationError(self.message)
-
-
 class TimeBetweenCheckForm(Form):
     weeks = IntegerField('Weeks', validators=[validators.Optional(), validators.NumberRange(min=0, message="Should contain zero or more seconds")])
     days = IntegerField('Days', validators=[validators.Optional(), validators.NumberRange(min=0, message="Should contain zero or more seconds")])
@@ -252,123 +220,6 @@ class TimeBetweenCheckForm(Form):
     seconds = IntegerField('Seconds', validators=[validators.Optional(), validators.NumberRange(min=0, message="Should contain zero or more seconds")])
     # @todo add total seconds minimum validatior = minimum_seconds_recheck_time
 
-    def __init__(self, formdata=None, obj=None, prefix="", data=None, meta=None, **kwargs):
-        super().__init__(formdata, obj, prefix, data, meta, **kwargs)
-        self.require_at_least_one = kwargs.get('require_at_least_one', False)
-        self.require_at_least_one_message = kwargs.get('require_at_least_one_message', REQUIRE_ATLEAST_ONE_TIME_PART_MESSAGE_DEFAULT)
-
-    def validate(self, **kwargs):
-        """Custom validation that can optionally require at least one time interval."""
-        # Run normal field validation first
-        if not super().validate(**kwargs):
-            return False
-
-        # Apply optional "at least one" validation
-        if self.require_at_least_one:
-            if not validate_time_between_check_has_values(self):
-                # Add error to the form's general errors (not field-specific)
-                if not hasattr(self, '_formdata_errors'):
-                    self._formdata_errors = []
-                self._formdata_errors.append(self.require_at_least_one_message)
-                return False
-
-        return True
-
-
-class EnhancedFormField(FormField):
-    """
-    An enhanced FormField that supports conditional validation with top-level error messages.
-    Adds a 'top_errors' property for validation errors at the FormField level.
-    """
-
-    def __init__(self, form_class, label=None, validators=None, separator="-",
-                 conditional_field=None, conditional_message=None, conditional_test_function=None, **kwargs):
-        """
-        Initialize EnhancedFormField with optional conditional validation.
-
-        :param conditional_field: Name of the field this FormField depends on (e.g. 'time_between_check_use_default')
-        :param conditional_message: Error message to show when validation fails
-        :param conditional_test_function: Custom function to test if FormField has valid values.
-                                        Should take self.form as parameter and return True if valid.
-        """
-        super().__init__(form_class, label, validators, separator, **kwargs)
-        self.top_errors = []
-        self.conditional_field = conditional_field
-        self.conditional_message = conditional_message or "At least one field must have a value when not using defaults."
-        self.conditional_test_function = conditional_test_function
-
-    def validate(self, form, extra_validators=()):
-        """
-        Custom validation that supports conditional logic and stores top-level errors.
-        """
-        self.top_errors = []
-
-        # First run the normal FormField validation
-        base_valid = super().validate(form, extra_validators)
-
-        # Apply conditional validation if configured
-        if self.conditional_field and hasattr(form, self.conditional_field):
-            conditional_field_obj = getattr(form, self.conditional_field)
-
-            # If the conditional field is False/unchecked, check if this FormField has any values
-            if not conditional_field_obj.data:
-                # Use custom test function if provided, otherwise use generic fallback
-                if self.conditional_test_function:
-                    has_any_value = self.conditional_test_function(self.form)
-                else:
-                    # Generic fallback - check if any field has truthy data
-                    has_any_value = any(field.data for field in self.form if hasattr(field, 'data') and field.data)
-
-                if not has_any_value:
-                    self.top_errors.append(self.conditional_message)
-                    base_valid = False
-
-        return base_valid
-
-
-class RequiredFormField(FormField):
-    """
-    A FormField that passes require_at_least_one=True to TimeBetweenCheckForm.
-    Use this when you want the sub-form to always require at least one value.
-    """
-
-    def __init__(self, form_class, label=None, validators=None, separator="-", **kwargs):
-        super().__init__(form_class, label, validators, separator, **kwargs)
-
-    def process(self, formdata, data=unset_value, extra_filters=None):
-        if extra_filters:
-            raise TypeError(
-                "FormField cannot take filters, as the encapsulated"
-                "data is not mutable."
-            )
-
-        if data is unset_value:
-            try:
-                data = self.default()
-            except TypeError:
-                data = self.default
-            self._obj = data
-
-        self.object_data = data
-
-        prefix = self.name + self.separator
-        # Pass require_at_least_one=True to the sub-form
-        if isinstance(data, dict):
-            self.form = self.form_class(formdata=formdata, prefix=prefix, require_at_least_one=True, **data)
-        else:
-            self.form = self.form_class(formdata=formdata, obj=data, prefix=prefix, require_at_least_one=True)
-
-    @property
-    def errors(self):
-        """Include sub-form validation errors"""
-        form_errors = self.form.errors
-        # Add any general form errors to a special 'form' key
-        if hasattr(self.form, '_formdata_errors') and self.form._formdata_errors:
-            form_errors = dict(form_errors)  # Make a copy
-            form_errors['form'] = self.form._formdata_errors
-        return form_errors
-
-
 # Separated by  key:value
 class StringDictKeyValue(StringField):
     widget = widgets.TextArea()
@@ -497,7 +348,7 @@ class ValidateJinja2Template(object):
         joined_data = ' '.join(map(str, field.data)) if isinstance(field.data, list) else f"{field.data}"
 
         try:
-            jinja2_env = ImmutableSandboxedEnvironment(loader=BaseLoader, extensions=['jinja2_time.TimeExtension'])
+            jinja2_env = ImmutableSandboxedEnvironment(loader=BaseLoader)
             jinja2_env.globals.update(notification.valid_tokens)
             # Extra validation tokens provided on the form_class(... extra_tokens={}) setup
             if hasattr(field, 'extra_notification_tokens'):
@@ -732,16 +583,11 @@ class processor_text_json_diff_form(commonSettingsForm):
     url = fields.URLField('URL', validators=[validateURL()])
     tags = StringTagUUID('Group tag', [validators.Optional()], default='')
 
-    time_between_check = EnhancedFormField(
-        TimeBetweenCheckForm,
-        conditional_field='time_between_check_use_default',
-        conditional_message=REQUIRE_ATLEAST_ONE_TIME_PART_WHEN_NOT_GLOBAL_DEFAULT,
-        conditional_test_function=validate_time_between_check_has_values
-    )
+    time_between_check = FormField(TimeBetweenCheckForm)
 
     time_schedule_limit = FormField(ScheduleLimitForm)
 
-    time_between_check_use_default = BooleanField('Use global settings for time between check and scheduler.', default=False)
+    time_between_check_use_default = BooleanField('Use global settings for time between check', default=False)
 
     include_filters = StringListField('CSS/JSONPath/JQ/XPath Filters', [ValidateCSSJSONXPATHInput()], default='')
 
@@ -759,7 +605,6 @@ class processor_text_json_diff_form(commonSettingsForm):
     check_unique_lines = BooleanField('Only trigger when unique lines appear in all history', default=False)
     remove_duplicate_lines = BooleanField('Remove duplicate lines of text', default=False)
     sort_text_alphabetically =  BooleanField('Sort text alphabetically', default=False)
-    strip_ignored_lines = TernaryNoneBooleanField('Strip ignored lines', default=None)
     trim_text_whitespace = BooleanField('Trim whitespace before and after text', default=False)
 
     filter_text_added = BooleanField('Added lines', default=True)
@@ -883,7 +728,7 @@ class DefaultUAInputForm(Form):
 
 # datastore.data['settings']['requests']..
 class globalSettingsRequestForm(Form):
-    time_between_check = RequiredFormField(TimeBetweenCheckForm)
+    time_between_check = FormField(TimeBetweenCheckForm)
     time_schedule_limit = FormField(ScheduleLimitForm)
     proxy = RadioField('Proxy')
     jitter_seconds = IntegerField('Random jitter seconds ± check',
@@ -937,7 +782,6 @@ class globalSettingsApplicationForm(commonSettingsForm):
     removepassword_button = SubmitField('Remove password', render_kw={"class": "pure-button pure-button-primary"})
     render_anchor_tag_content = BooleanField('Render anchor tag content', default=False)
     shared_diff_access = BooleanField('Allow anonymous access to watch history page when password is enabled', default=False, validators=[validators.Optional()])
-    strip_ignored_lines = BooleanField('Strip ignored lines')
     rss_hide_muted_watches = BooleanField('Hide muted watches from RSS feed', default=True,
                                       validators=[validators.Optional()])
     filter_failure_notification_threshold_attempts = IntegerField('Number of times the filter can be missing before sending a notification',

changedetectionio/html_tools.py

@@ -100,7 +100,7 @@ def element_removal(selectors: List[str], html_content):
     xpath_selectors = []
 
     for selector in selectors:
-        if selector.strip().startswith(('xpath:', 'xpath1:', '//')):
+        if selector.startswith(('xpath:', 'xpath1:', '//')):
             # Handle XPath selectors separately
             xpath_selector = selector.removeprefix('xpath:').removeprefix('xpath1:')
             xpath_selectors.append(xpath_selector)

changedetectionio/model/App.py

@@ -57,7 +57,6 @@ class model(dict):
                     'rss_hide_muted_watches': True,
                     'schema_version' : 0,
                     'shared_diff_access': False,
-                    'strip_ignored_lines': False,
                     'tags': {}, #@todo use Tag.model initialisers
                     'timezone': None, # Default IANA timezone name
                     'webdriver_delay': None , # Extra delay in seconds before extracting text

changedetectionio/model/Watch.py

@@ -170,7 +170,7 @@ class model(watch_base):
     @property
     def label(self):
         # Used for sorting, display, etc
-        return self.get('title') or self.get('page_title') or self.link
+        return self.get('title') or self.get('page_title') or self.get('url')
 
     @property
     def last_changed(self):

changedetectionio/model/__init__.py

@@ -58,7 +58,6 @@ class watch_base(dict):
             'proxy': None,  # Preferred proxy connection
             'remote_server_reply': None,  # From 'server' reply header
             'sort_text_alphabetically': False,
-            'strip_ignored_lines': None,
             'subtractive_selectors': [],
             'tag': '',  # Old system of text name for a tag, to be removed
             'tags': [],  # list of UUIDs to App.Tags

changedetectionio/processors/magic.py

@@ -1,125 +0,0 @@
-"""
-Content Type Detection and Stream Classification
-
-This module provides intelligent content-type detection for changedetection.io.
-It addresses the common problem where HTTP Content-Type headers are missing, incorrect,
-or too generic, which would otherwise cause the wrong processor to be used.
-
-The guess_stream_type class combines:
-1. HTTP Content-Type headers (when available and reliable)
-2. Python-magic library for MIME detection (analyzing actual file content)
-3. Content-based pattern matching for text formats (HTML tags, XML declarations, etc.)
-
-This multi-layered approach ensures accurate detection of RSS feeds, JSON, HTML, PDF,
-plain text, CSV, YAML, and XML formats - even when servers provide misleading headers.
-
-Used by: processors/text_json_diff/processor.py and other content processors
-"""
-
-# When to apply the 'cdata to real HTML' hack
-RSS_XML_CONTENT_TYPES = [
-    "application/rss+xml",
-    "application/rdf+xml",
-    "application/atom+xml",
-    "text/rss+xml",  # rare, non-standard
-    "application/x-rss+xml",  # legacy (older feed software)
-    "application/x-atom+xml",  # legacy (older Atom)
-]
-
-# JSON Content-types
-JSON_CONTENT_TYPES = [
-    "application/activity+json",
-    "application/feed+json",
-    "application/json",
-    "application/ld+json",
-    "application/vnd.api+json",
-]
-
-
-# Generic XML Content-types (non-RSS/Atom)
-XML_CONTENT_TYPES = [
-    "text/xml",
-    "application/xml",
-]
-
-HTML_PATTERNS = ['<!doctype html', '<html', '<head', '<body', '<script', '<iframe', '<div']
-
-from loguru import logger
-
-class guess_stream_type():
-    is_pdf = False
-    is_json = False
-    is_html = False
-    is_plaintext = False
-    is_rss = False
-    is_csv = False
-    is_xml = False  # Generic XML, not RSS/Atom
-    is_yaml = False
-
-    def __init__(self, http_content_header, content):
-        import re
-        magic_content_header = http_content_header
-        test_content = content[:200].lower().strip()
-
-        # Remove whitespace between < and tag name for robust detection (handles '< html', '<\nhtml', etc.)
-        test_content_normalized = re.sub(r'<\s+', '<', test_content)
-
-        # Magic will sometimes call text/plain as text/html!
-        magic_result = None
-        try:
-            import magic
-
-            mime = magic.from_buffer(content[:200], mime=True) # Send the original content
-            logger.debug(f"Guessing mime type, original content_type '{http_content_header}', mime type detected '{mime}'")
-            if mime and "/" in mime:
-                magic_result = mime
-                # Ignore generic/fallback mime types from magic
-                if mime in ['application/octet-stream', 'application/x-empty', 'binary']:
-                    logger.debug(f"Ignoring generic mime type '{mime}' from magic library")
-                # Trust magic for non-text types immediately
-                elif mime not in ['text/html', 'text/plain']:
-                    magic_content_header = mime
-
-        except Exception as e:
-            logger.error(f"Error getting a more precise mime type from 'magic' library ({str(e)}), using content-based detection")
-
-        # Content-based detection (most reliable for text formats)
-        # Check for HTML patterns first - if found, override magic's text/plain
-        has_html_patterns = any(p in test_content_normalized for p in HTML_PATTERNS)
-
-        # Always trust headers first
-        if 'text/plain' in http_content_header:
-            self.is_plaintext = True
-        if any(s in http_content_header for s in RSS_XML_CONTENT_TYPES):
-            self.is_rss = True
-        elif any(s in http_content_header for s in JSON_CONTENT_TYPES):
-            self.is_json = True
-        elif any(s in http_content_header for s in XML_CONTENT_TYPES):
-            # Only mark as generic XML if not already detected as RSS
-            if not self.is_rss:
-                self.is_xml = True
-        elif 'pdf' in magic_content_header:
-            self.is_pdf = True
-###
-        elif has_html_patterns or http_content_header == 'text/html':
-            self.is_html = True
-        # If magic says text/plain and we found no HTML patterns, trust it
-        elif magic_result == 'text/plain':
-            self.is_plaintext = True
-            logger.debug(f"Trusting magic's text/plain result (no HTML patterns detected)")
-        elif any(s in magic_content_header for s in JSON_CONTENT_TYPES):
-            self.is_json = True
-        # magic will call a rss document 'xml'
-        elif '<rss' in test_content_normalized or '<feed' in test_content_normalized or any(s in magic_content_header for s in RSS_XML_CONTENT_TYPES):
-            self.is_rss = True
-        elif test_content_normalized.startswith('<?xml') or any(s in magic_content_header for s in XML_CONTENT_TYPES):
-            # Generic XML that's not RSS/Atom (RSS/Atom checked above)
-            self.is_xml = True
-        elif '%pdf-1' in test_content:
-            self.is_pdf = True
-        elif http_content_header.startswith('text/'):
-            self.is_plaintext = True
-        # Only trust magic for 'text' if no other patterns matched
-        elif 'text' in magic_content_header:
-            self.is_plaintext = True
-

changedetectionio/processors/text_json_diff/processor.py

@@ -13,8 +13,6 @@ from changedetectionio import html_tools, content_fetchers
 from changedetectionio.blueprint.price_data_follower import PRICE_DATA_TRACK_ACCEPT, PRICE_DATA_TRACK_REJECT
 from loguru import logger
 
-from changedetectionio.processors.magic import guess_stream_type
-
 urllib3.disable_warnings(urllib3.exceptions.InsecureRequestWarning)
 
 name = 'Webpage Text/HTML, JSON and PDF changes'
@@ -22,9 +20,6 @@ description = 'Detects all text changes where possible'
 
 json_filter_prefixes = ['json:', 'jq:', 'jqraw:']
 
-# Assume it's this type if the server says nothing on content-type
-DEFAULT_WHEN_NO_CONTENT_TYPE_HEADER = 'text/html'
-
 class FilterNotFoundInResponse(ValueError):
     def __init__(self, msg, screenshot=None, xpath_data=None):
         self.screenshot = screenshot
@@ -37,520 +32,353 @@ class PDFToHTMLToolNotFound(ValueError):
         ValueError.__init__(self, msg)
 
 
-class FilterConfig:
-    """Consolidates all filter and rule configurations from watch, tags, and global settings."""
-
-    def __init__(self, watch, datastore):
-        self.watch = watch
-        self.datastore = datastore
-        self.watch_uuid = watch.get('uuid')
-        # Cache computed properties to avoid repeated list operations
-        self._include_filters_cache = None
-        self._subtractive_selectors_cache = None
-
-    def _get_merged_rules(self, attr, include_global=False):
-        """Merge rules from watch, tags, and optionally global settings."""
-        watch_rules = self.watch.get(attr, [])
-        tag_rules = self.datastore.get_tag_overrides_for_watch(uuid=self.watch_uuid, attr=attr)
-        rules = list(dict.fromkeys(watch_rules + tag_rules))
-
-        if include_global:
-            global_rules = self.datastore.data['settings']['application'].get(f'global_{attr}', [])
-            rules = list(dict.fromkeys(rules + global_rules))
-
-        return rules
-
-    @property
-    def include_filters(self):
-        if self._include_filters_cache is None:
-            filters = self._get_merged_rules('include_filters')
-            # Inject LD+JSON price tracker rule if enabled
-            if self.watch.get('track_ldjson_price_data', '') == PRICE_DATA_TRACK_ACCEPT:
-                filters += html_tools.LD_JSON_PRODUCT_OFFER_SELECTORS
-            self._include_filters_cache = filters
-        return self._include_filters_cache
-
-    @property
-    def subtractive_selectors(self):
-        if self._subtractive_selectors_cache is None:
-            watch_selectors = self.watch.get("subtractive_selectors", [])
-            tag_selectors = self.datastore.get_tag_overrides_for_watch(uuid=self.watch_uuid, attr='subtractive_selectors')
-            global_selectors = self.datastore.data["settings"]["application"].get("global_subtractive_selectors", [])
-            self._subtractive_selectors_cache = [*tag_selectors, *watch_selectors, *global_selectors]
-        return self._subtractive_selectors_cache
-
-    @property
-    def extract_text(self):
-        return self._get_merged_rules('extract_text')
-
-    @property
-    def ignore_text(self):
-        return self._get_merged_rules('ignore_text', include_global=True)
-
-    @property
-    def trigger_text(self):
-        return self._get_merged_rules('trigger_text')
-
-    @property
-    def text_should_not_be_present(self):
-        return self._get_merged_rules('text_should_not_be_present')
-
-    @property
-    def has_include_filters(self):
-        return bool(self.include_filters) and bool(self.include_filters[0].strip())
-
-    @property
-    def has_subtractive_selectors(self):
-        return bool(self.subtractive_selectors) and bool(self.subtractive_selectors[0].strip())
-
-
-class ContentTransformer:
-    """Handles text transformations like trimming, sorting, and deduplication."""
-
-    @staticmethod
-    def trim_whitespace(text):
-        """Remove leading/trailing whitespace from each line."""
-        # Use generator expression to avoid building intermediate list
-        return '\n'.join(line.strip() for line in text.replace("\n\n", "\n").splitlines())
-
-    @staticmethod
-    def remove_duplicate_lines(text):
-        """Remove duplicate lines while preserving order."""
-        return '\n'.join(dict.fromkeys(line for line in text.replace("\n\n", "\n").splitlines()))
-
-    @staticmethod
-    def sort_alphabetically(text):
-        """Sort lines alphabetically (case-insensitive)."""
-        # Remove double line feeds before sorting
-        text = text.replace("\n\n", "\n")
-        return '\n'.join(sorted(text.splitlines(), key=lambda x: x.lower()))
-
-    @staticmethod
-    def extract_by_regex(text, regex_patterns):
-        """Extract text matching regex patterns."""
-        # Use list of strings instead of concatenating lists repeatedly (avoids O(n²) behavior)
-        regex_matched_output = []
-
-        for s_re in regex_patterns:
-            # Check if it's perl-style regex /.../
-            if re.search(PERL_STYLE_REGEX, s_re, re.IGNORECASE):
-                regex = html_tools.perl_style_slash_enclosed_regex_to_options(s_re)
-                result = re.findall(regex, text)
-
-                for match in result:
-                    if type(match) is tuple:
-                        regex_matched_output.extend(match)
-                        regex_matched_output.append('\n')
-                    else:
-                        regex_matched_output.append(match)
-                        regex_matched_output.append('\n')
-            else:
-                # Plain text search (case-insensitive)
-                r = re.compile(re.escape(s_re), re.IGNORECASE)
-                res = r.findall(text)
-                if res:
-                    for match in res:
-                        regex_matched_output.append(match)
-                        regex_matched_output.append('\n')
-
-        return ''.join(regex_matched_output) if regex_matched_output else ''
-
-
-class RuleEngine:
-    """Evaluates blocking rules (triggers, conditions, text_should_not_be_present)."""
-
-    @staticmethod
-    def evaluate_trigger_text(content, trigger_patterns):
-        """
-        Check if trigger text is present. If trigger_text is configured,
-        content is blocked UNLESS the trigger is found.
-        Returns True if blocked, False if allowed.
-        """
-        if not trigger_patterns:
-            return False
-
-        # Assume blocked if trigger_text is configured
-        result = html_tools.strip_ignore_text(
-            content=str(content),
-            wordlist=trigger_patterns,
-            mode="line numbers"
-        )
-        # Unblock if trigger was found
-        return not bool(result)
-
-    @staticmethod
-    def evaluate_text_should_not_be_present(content, patterns):
-        """
-        Check if forbidden text is present. If found, block the change.
-        Returns True if blocked, False if allowed.
-        """
-        if not patterns:
-            return False
-
-        result = html_tools.strip_ignore_text(
-            content=str(content),
-            wordlist=patterns,
-            mode="line numbers"
-        )
-        # Block if forbidden text was found
-        return bool(result)
-
-    @staticmethod
-    def evaluate_conditions(watch, datastore, content):
-        """
-        Evaluate custom conditions ruleset.
-        Returns True if blocked, False if allowed.
-        """
-        if not watch.get('conditions') or not watch.get('conditions_match_logic'):
-            return False
-
-        conditions_result = execute_ruleset_against_all_plugins(
-            current_watch_uuid=watch.get('uuid'),
-            application_datastruct=datastore.data,
-            ephemeral_data={'text': content}
-        )
-
-        # Block if conditions not met
-        return not conditions_result.get('result')
-
-
-class ContentProcessor:
-    """Handles content preprocessing, filtering, and extraction."""
-
-    def __init__(self, fetcher, watch, filter_config, datastore):
-        self.fetcher = fetcher
-        self.watch = watch
-        self.filter_config = filter_config
-        self.datastore = datastore
-
-    def preprocess_rss(self, content):
-        """Convert CDATA/comments in RSS to usable text."""
-        return cdata_in_document_to_text(html_content=content)
-
-    def preprocess_pdf(self, raw_content):
-        """Convert PDF to HTML using external tool."""
-        from shutil import which
-        tool = os.getenv("PDF_TO_HTML_TOOL", "pdftohtml")
-        if not which(tool):
-            raise PDFToHTMLToolNotFound(
-                f"Command-line `{tool}` tool was not found in system PATH, was it installed?"
-            )
-
-        import subprocess
-        proc = subprocess.Popen(
-            [tool, '-stdout', '-', '-s', 'out.pdf', '-i'],
-            stdout=subprocess.PIPE,
-            stdin=subprocess.PIPE
-        )
-        proc.stdin.write(raw_content)
-        proc.stdin.close()
-        html_content = proc.stdout.read().decode('utf-8')
-        proc.wait(timeout=60)
-
-        # Add metadata for change detection
-        metadata = (
-            f"<p>Added by changedetection.io: Document checksum - "
-            f"{hashlib.md5(raw_content).hexdigest().upper()} "
-            f"Original file size - {len(raw_content)} bytes</p>"
-        )
-        return html_content.replace('</body>', metadata + '</body>')
-
-    def preprocess_json(self, content, has_filters):
-        """Format and sort JSON content."""
-        # Force reformat if no filters specified
-        if not has_filters:
-            content = html_tools.extract_json_as_string(content=content, json_filter="json:$")
-
-        # Sort JSON to avoid false alerts from reordering
-        try:
-            content = json.dumps(json.loads(content), sort_keys=True)
-        except Exception:
-            # Might be malformed JSON, continue anyway
-            pass
-
-        return content
-
-    def apply_include_filters(self, content, stream_content_type):
-        """Apply CSS, XPath, or JSON filters to extract specific content."""
-        filtered_content = ""
-
-        for filter_rule in self.filter_config.include_filters:
-            # XPath filters
-            if filter_rule[0] == '/' or filter_rule.startswith('xpath:'):
-                filtered_content += html_tools.xpath_filter(
-                    xpath_filter=filter_rule.replace('xpath:', ''),
-                    html_content=content,
-                    append_pretty_line_formatting=not self.watch.is_source_type_url,
-                    is_rss=stream_content_type.is_rss
-                )
-
-            # XPath1 filters (first match only)
-            elif filter_rule.startswith('xpath1:'):
-                filtered_content += html_tools.xpath1_filter(
-                    xpath_filter=filter_rule.replace('xpath1:', ''),
-                    html_content=content,
-                    append_pretty_line_formatting=not self.watch.is_source_type_url,
-                    is_rss=stream_content_type.is_rss
-                )
-
-            # JSON filters
-            elif any(filter_rule.startswith(prefix) for prefix in json_filter_prefixes):
-                filtered_content += html_tools.extract_json_as_string(
-                    content=content,
-                    json_filter=filter_rule
-                )
-
-            # CSS selectors, default fallback
-            else:
-                filtered_content += html_tools.include_filters(
-                    include_filters=filter_rule,
-                    html_content=content,
-                    append_pretty_line_formatting=not self.watch.is_source_type_url
-                )
-
-            # Raise error if filter returned nothing
-            if not filtered_content.strip():
-                raise FilterNotFoundInResponse(
-                    msg=self.filter_config.include_filters,
-                    screenshot=self.fetcher.screenshot,
-                    xpath_data=self.fetcher.xpath_data
-                )
-
-        return filtered_content
-
-    def apply_subtractive_selectors(self, content):
-        """Remove elements matching subtractive selectors."""
-        return html_tools.element_removal(self.filter_config.subtractive_selectors, content)
-
-    def extract_text_from_html(self, html_content, stream_content_type):
-        """Convert HTML to plain text."""
-        do_anchor = self.datastore.data["settings"]["application"].get("render_anchor_tag_content", False)
-        return html_tools.html_to_text(
-            html_content=html_content,
-            render_anchor_tag_content=do_anchor,
-            is_rss=stream_content_type.is_rss
-        )
-
-
-class ChecksumCalculator:
-    """Calculates checksums with various options."""
-
-    @staticmethod
-    def calculate(text, ignore_whitespace=False):
-        """Calculate MD5 checksum of text content."""
-        if ignore_whitespace:
-            text = text.translate(TRANSLATE_WHITESPACE_TABLE)
-        return hashlib.md5(text.encode('utf-8')).hexdigest()
-
-
 # Some common stuff here that can be moved to a base class
 # (set_proxy_from_list)
 class perform_site_check(difference_detection_processor):
 
     def run_changedetection(self, watch):
         changed_detected = False
+        html_content = ""
+        screenshot = False  # as bytes
+        stripped_text_from_html = ""
 
         if not watch:
             raise Exception("Watch no longer exists.")
 
-        # Initialize components
-        filter_config = FilterConfig(watch, self.datastore)
-        content_processor = ContentProcessor(self.fetcher, watch, filter_config, self.datastore)
-        transformer = ContentTransformer()
-        rule_engine = RuleEngine()
-
-        # Get content type and stream info
-        ctype_header = self.fetcher.get_all_headers().get('content-type', DEFAULT_WHEN_NO_CONTENT_TYPE_HEADER).lower()
-        stream_content_type = guess_stream_type(http_content_header=ctype_header, content=self.fetcher.content)
-
         # Unset any existing notification error
         update_obj = {'last_notification_error': False, 'last_error': False}
+
         url = watch.link
 
         self.screenshot = self.fetcher.screenshot
         self.xpath_data = self.fetcher.xpath_data
 
-        # Track the content type and checksum before filters
-        update_obj['content_type'] = ctype_header
+        # Track the content type
+        update_obj['content_type'] = self.fetcher.get_all_headers().get('content-type', '').lower()
+
+        # Watches added automatically in the queue manager will skip if its the same checksum as the previous run
+        # Saves a lot of CPU
         update_obj['previous_md5_before_filters'] = hashlib.md5(self.fetcher.content.encode('utf-8')).hexdigest()
 
-        # === CONTENT PREPROCESSING ===
-        # Avoid creating unnecessary intermediate string copies by reassigning only when needed
-        content = self.fetcher.content
+        # Fetching complete, now filters
 
-        # RSS preprocessing
-        if stream_content_type.is_rss:
-            content = content_processor.preprocess_rss(content)
+        # @note: I feel like the following should be in a more obvious chain system
+        #  - Check filter text
+        #  - Is the checksum different?
+        #  - Do we convert to JSON?
+        # https://stackoverflow.com/questions/41817578/basic-method-chaining ?
+        # return content().textfilter().jsonextract().checksumcompare() ?
 
-        # PDF preprocessing
-        if watch.is_pdf or stream_content_type.is_pdf:
-            content = content_processor.preprocess_pdf(raw_content=self.fetcher.raw_content)
-            stream_content_type.is_html = True
+        is_json = 'application/json' in self.fetcher.get_all_headers().get('content-type', '').lower()
+        is_html = not is_json
+        is_rss = False
 
-        # JSON preprocessing
-        if stream_content_type.is_json:
-            content = content_processor.preprocess_json(content, filter_config.has_include_filters)
+        ctype_header = self.fetcher.get_all_headers().get('content-type', '').lower()
+        # Go into RSS preprocess for converting CDATA/comment to usable text
+        if any(substring in ctype_header for substring in ['application/xml', 'application/rss', 'text/xml']):
+            if '<rss' in self.fetcher.content[:100].lower():
+                self.fetcher.content = cdata_in_document_to_text(html_content=self.fetcher.content)
+                is_rss = True
 
-        # HTML obfuscation workarounds
-        if stream_content_type.is_html:
-            content = html_tools.workarounds_for_obfuscations(content)
-
-        # Check for LD+JSON price data (for HTML content)
-        if stream_content_type.is_html:
-            update_obj['has_ldjson_price_data'] = html_tools.has_ldjson_product_info(content)
-
-        # === FILTER APPLICATION ===
-        # Start with content reference, avoid copy until modification
-        html_content = content
-
-        # Apply include filters (CSS, XPath, JSON)
-        if filter_config.has_include_filters:
-            html_content = content_processor.apply_include_filters(content, stream_content_type)
-
-        # Apply subtractive selectors
-        if filter_config.has_subtractive_selectors:
-            html_content = content_processor.apply_subtractive_selectors(html_content)
-
-        # === TEXT EXTRACTION ===
+        # source: support, basically treat it as plaintext
         if watch.is_source_type_url:
-            # For source URLs, keep raw content
-            stripped_text = html_content
-        elif stream_content_type.is_plaintext:
-            # For plaintext, keep as-is without HTML-to-text conversion
-            stripped_text = html_content
-        else:
-            # Extract text from HTML/RSS content (not generic XML)
-            if stream_content_type.is_html or stream_content_type.is_rss:
-                stripped_text = content_processor.extract_text_from_html(html_content, stream_content_type)
+            is_html = False
+            is_json = False
+
+        inline_pdf = self.fetcher.get_all_headers().get('content-disposition', '') and '%PDF-1' in self.fetcher.content[:10]
+        if watch.is_pdf or 'application/pdf' in self.fetcher.get_all_headers().get('content-type', '').lower() or inline_pdf:
+            from shutil import which
+            tool = os.getenv("PDF_TO_HTML_TOOL", "pdftohtml")
+            if not which(tool):
+                raise PDFToHTMLToolNotFound("Command-line `{}` tool was not found in system PATH, was it installed?".format(tool))
+
+            import subprocess
+            proc = subprocess.Popen(
+                [tool, '-stdout', '-', '-s', 'out.pdf', '-i'],
+                stdout=subprocess.PIPE,
+                stdin=subprocess.PIPE)
+            proc.stdin.write(self.fetcher.raw_content)
+            proc.stdin.close()
+            self.fetcher.content = proc.stdout.read().decode('utf-8')
+            proc.wait(timeout=60)
+
+            # Add a little metadata so we know if the file changes (like if an image changes, but the text is the same
+            # @todo may cause problems with non-UTF8?
+            metadata = "<p>Added by changedetection.io: Document checksum - {} Filesize - {} bytes</p>".format(
+                hashlib.md5(self.fetcher.raw_content).hexdigest().upper(),
+                len(self.fetcher.content))
+
+            self.fetcher.content = self.fetcher.content.replace('</body>', metadata + '</body>')
+
+        # Better would be if Watch.model could access the global data also
+        # and then use getattr https://docs.python.org/3/reference/datamodel.html#object.__getitem__
+        # https://realpython.com/inherit-python-dict/ instead of doing it procedurely
+        include_filters_from_tags = self.datastore.get_tag_overrides_for_watch(uuid=watch.get('uuid'), attr='include_filters')
+
+        # 1845 - remove duplicated filters in both group and watch include filter
+        include_filters_rule = list(dict.fromkeys(watch.get('include_filters', []) + include_filters_from_tags))
+
+        subtractive_selectors = [*self.datastore.get_tag_overrides_for_watch(uuid=watch.get('uuid'), attr='subtractive_selectors'),
+                                 *watch.get("subtractive_selectors", []),
+                                 *self.datastore.data["settings"]["application"].get("global_subtractive_selectors", [])
+                                 ]
+
+        # Inject a virtual LD+JSON price tracker rule
+        if watch.get('track_ldjson_price_data', '') == PRICE_DATA_TRACK_ACCEPT:
+            include_filters_rule += html_tools.LD_JSON_PRODUCT_OFFER_SELECTORS
+
+        has_filter_rule = len(include_filters_rule) and len(include_filters_rule[0].strip())
+        has_subtractive_selectors = len(subtractive_selectors) and len(subtractive_selectors[0].strip())
+
+        if is_json and not has_filter_rule:
+            include_filters_rule.append("json:$")
+            has_filter_rule = True
+
+        if is_json:
+            # Sort the JSON so we dont get false alerts when the content is just re-ordered
+            try:
+                self.fetcher.content = json.dumps(json.loads(self.fetcher.content), sort_keys=True)
+            except Exception as e:
+                # Might have just been a snippet, or otherwise bad JSON, continue
+                pass
+
+        if has_filter_rule:
+            for filter in include_filters_rule:
+                if any(prefix in filter for prefix in json_filter_prefixes):
+                    stripped_text_from_html += html_tools.extract_json_as_string(content=self.fetcher.content, json_filter=filter)
+                    is_html = False
+
+        if is_html or watch.is_source_type_url:
+
+            # CSS Filter, extract the HTML that matches and feed that into the existing inscriptis::get_text
+            self.fetcher.content = html_tools.workarounds_for_obfuscations(self.fetcher.content)
+            html_content = self.fetcher.content
+
+            # If not JSON,  and if it's not text/plain..
+            if 'text/plain' in self.fetcher.get_all_headers().get('content-type', '').lower():
+                # Don't run get_text or xpath/css filters on plaintext
+                stripped_text_from_html = html_content
             else:
-                stripped_text = html_content
+                # Does it have some ld+json price data? used for easier monitoring
+                update_obj['has_ldjson_price_data'] = html_tools.has_ldjson_product_info(self.fetcher.content)
+
+                # Then we assume HTML
+                if has_filter_rule:
+                    html_content = ""
+
+                    for filter_rule in include_filters_rule:
+                        # For HTML/XML we offer xpath as an option, just start a regular xPath "/.."
+                        if filter_rule[0] == '/' or filter_rule.startswith('xpath:'):
+                            html_content += html_tools.xpath_filter(xpath_filter=filter_rule.replace('xpath:', ''),
+                                                                    html_content=self.fetcher.content,
+                                                                    append_pretty_line_formatting=not watch.is_source_type_url,
+                                                                    is_rss=is_rss)
+
+                        elif filter_rule.startswith('xpath1:'):
+                            html_content += html_tools.xpath1_filter(xpath_filter=filter_rule.replace('xpath1:', ''),
+                                                                     html_content=self.fetcher.content,
+                                                                     append_pretty_line_formatting=not watch.is_source_type_url,
+                                                                     is_rss=is_rss)
+                        else:
+                            html_content += html_tools.include_filters(include_filters=filter_rule,
+                                                                       html_content=self.fetcher.content,
+                                                                       append_pretty_line_formatting=not watch.is_source_type_url)
+
+                    if not html_content.strip():
+                        raise FilterNotFoundInResponse(msg=include_filters_rule, screenshot=self.fetcher.screenshot, xpath_data=self.fetcher.xpath_data)
+
+                if has_subtractive_selectors:
+                    html_content = html_tools.element_removal(subtractive_selectors, html_content)
+
+                if watch.is_source_type_url:
+                    stripped_text_from_html = html_content
+                else:
+                    # extract text
+                    do_anchor = self.datastore.data["settings"]["application"].get("render_anchor_tag_content", False)
+                    stripped_text_from_html = html_tools.html_to_text(html_content=html_content,
+                                                                      render_anchor_tag_content=do_anchor,
+                                                                      is_rss=is_rss)  # 1874 activate the <title workaround hack
 
-        # === TEXT TRANSFORMATIONS ===
         if watch.get('trim_text_whitespace'):
-            stripped_text = transformer.trim_whitespace(stripped_text)
+            stripped_text_from_html = '\n'.join(line.strip() for line in stripped_text_from_html.replace("\n\n", "\n").splitlines())
 
-        # Save text before ignore filters (for diff calculation)
-        text_content_before_ignored_filter = stripped_text
+        # Re #340 - return the content before the 'ignore text' was applied
+        # Also used to calculate/show what was removed
+        text_content_before_ignored_filter = stripped_text_from_html
+
+        # @todo whitespace coming from missing rtrim()?
+        # stripped_text_from_html could be based on their preferences, replace the processed text with only that which they want to know about.
+        # Rewrite's the processing text based on only what diff result they want to see
 
-        # === DIFF FILTERING ===
-        # If user wants specific diff types (added/removed/replaced only)
         if watch.has_special_diff_filter_options_set() and len(watch.history.keys()):
-            stripped_text = self._apply_diff_filtering(watch, stripped_text, text_content_before_ignored_filter)
-            if stripped_text is None:
-                # No differences found, but content exists
-                c = ChecksumCalculator.calculate(text_content_before_ignored_filter, ignore_whitespace=True)
-                return False, {'previous_md5': c}, text_content_before_ignored_filter.encode('utf-8')
+            # Now the content comes from the diff-parser and not the returned HTTP traffic, so could be some differences
+            from changedetectionio import diff
+            # needs to not include (added) etc or it may get used twice
+            # Replace the processed text with the preferred result
+            rendered_diff = diff.render_diff(previous_version_file_contents=watch.get_last_fetched_text_before_filters(),
+                                             newest_version_file_contents=stripped_text_from_html,
+                                             include_equal=False,  # not the same lines
+                                             include_added=watch.get('filter_text_added', True),
+                                             include_removed=watch.get('filter_text_removed', True),
+                                             include_replaced=watch.get('filter_text_replaced', True),
+                                             line_feed_sep="\n",
+                                             include_change_type_prefix=False)
 
-        # === EMPTY PAGE CHECK ===
+            watch.save_last_text_fetched_before_filters(text_content_before_ignored_filter.encode('utf-8'))
+
+            if not rendered_diff and stripped_text_from_html:
+                # We had some content, but no differences were found
+                # Store our new file as the MD5 so it will trigger in the future
+                c = hashlib.md5(stripped_text_from_html.translate(TRANSLATE_WHITESPACE_TABLE).encode('utf-8')).hexdigest()
+                return False, {'previous_md5': c}, stripped_text_from_html.encode('utf-8')
+            else:
+                stripped_text_from_html = rendered_diff
+
+        # Treat pages with no renderable text content as a change? No by default
         empty_pages_are_a_change = self.datastore.data['settings']['application'].get('empty_pages_are_a_change', False)
-        if not stream_content_type.is_json and not empty_pages_are_a_change and len(stripped_text.strip()) == 0:
-            raise content_fetchers.exceptions.ReplyWithContentButNoText(
-                url=url,
-                status_code=self.fetcher.get_last_status_code(),
-                screenshot=self.fetcher.screenshot,
-                has_filters=filter_config.has_include_filters,
-                html_content=html_content,
-                xpath_data=self.fetcher.xpath_data
-            )
+        if not is_json and not empty_pages_are_a_change and len(stripped_text_from_html.strip()) == 0:
+            raise content_fetchers.exceptions.ReplyWithContentButNoText(url=url,
+                                                            status_code=self.fetcher.get_last_status_code(),
+                                                            screenshot=self.fetcher.screenshot,
+                                                            has_filters=has_filter_rule,
+                                                            html_content=html_content,
+                                                            xpath_data=self.fetcher.xpath_data
+                                                            )
+
+        # We rely on the actual text in the html output.. many sites have random script vars etc,
+        # in the future we'll implement other mechanisms.
 
         update_obj["last_check_status"] = self.fetcher.get_last_status_code()
 
-        # === REGEX EXTRACTION ===
-        if filter_config.extract_text:
-            extracted = transformer.extract_by_regex(stripped_text, filter_config.extract_text)
-            stripped_text = extracted
+        # 615 Extract text by regex
+        extract_text = list(dict.fromkeys(watch.get('extract_text', []) + self.datastore.get_tag_overrides_for_watch(uuid=watch.get('uuid'), attr='extract_text')))
+        if len(extract_text) > 0:
+            regex_matched_output = []
+            for s_re in extract_text:
+                # incase they specified something in '/.../x'
+                if re.search(PERL_STYLE_REGEX, s_re, re.IGNORECASE):
+                    regex = html_tools.perl_style_slash_enclosed_regex_to_options(s_re)
+                    result = re.findall(regex, stripped_text_from_html)
+
+                    for l in result:
+                        if type(l) is tuple:
+                            # @todo - some formatter option default (between groups)
+                            regex_matched_output += list(l) + ['\n']
+                        else:
+                            # @todo - some formatter option default (between each ungrouped result)
+                            regex_matched_output += [l] + ['\n']
+                else:
+                    # Doesnt look like regex, just hunt for plaintext and return that which matches
+                    # `stripped_text_from_html` will be bytes, so we must encode s_re also to bytes
+                    r = re.compile(re.escape(s_re), re.IGNORECASE)
+                    res = r.findall(stripped_text_from_html)
+                    if res:
+                        for match in res:
+                            regex_matched_output += [match] + ['\n']
+
+            ##########################################################
+            stripped_text_from_html = ''
+
+            if regex_matched_output:
+                # @todo some formatter for presentation?
+                stripped_text_from_html = ''.join(regex_matched_output)
 
-        # === MORE TEXT TRANSFORMATIONS ===
         if watch.get('remove_duplicate_lines'):
-            stripped_text = transformer.remove_duplicate_lines(stripped_text)
+            stripped_text_from_html = '\n'.join(dict.fromkeys(line for line in stripped_text_from_html.replace("\n\n", "\n").splitlines()))
+
 
         if watch.get('sort_text_alphabetically'):
-            stripped_text = transformer.sort_alphabetically(stripped_text)
+            # Note: Because a <p>something</p> will add an extra line feed to signify the paragraph gap
+            # we end up with 'Some text\n\n', sorting will add all those extra \n at the start, so we remove them here.
+            stripped_text_from_html = stripped_text_from_html.replace("\n\n", "\n")
+            stripped_text_from_html = '\n'.join(sorted(stripped_text_from_html.splitlines(), key=lambda x: x.lower()))
 
-        # === CHECKSUM CALCULATION ===
-        text_for_checksuming = stripped_text
+### CALCULATE MD5
+        # If there's text to ignore
+        text_to_ignore = watch.get('ignore_text', []) + self.datastore.data['settings']['application'].get('global_ignore_text', [])
+        text_to_ignore += self.datastore.get_tag_overrides_for_watch(uuid=watch.get('uuid'), attr='ignore_text')
 
-        # Apply ignore_text for checksum calculation
-        if filter_config.ignore_text:
-            text_for_checksuming = html_tools.strip_ignore_text(stripped_text, filter_config.ignore_text)
+        text_for_checksuming = stripped_text_from_html
+        if text_to_ignore:
+            text_for_checksuming = html_tools.strip_ignore_text(stripped_text_from_html, text_to_ignore)
 
-            # Optionally remove ignored lines from output
-            strip_ignored_lines = watch.get('strip_ignored_lines')
-            if strip_ignored_lines is None:
-                strip_ignored_lines = self.datastore.data['settings']['application'].get('strip_ignored_lines')
-            if strip_ignored_lines:
-                stripped_text = text_for_checksuming
+        # Re #133 - if we should strip whitespaces from triggering the change detected comparison
+        if text_for_checksuming and self.datastore.data['settings']['application'].get('ignore_whitespace', False):
+            fetched_md5 = hashlib.md5(text_for_checksuming.translate(TRANSLATE_WHITESPACE_TABLE).encode('utf-8')).hexdigest()
+        else:
+            fetched_md5 = hashlib.md5(text_for_checksuming.encode('utf-8')).hexdigest()
 
-        # Calculate checksum
-        ignore_whitespace = self.datastore.data['settings']['application'].get('ignore_whitespace', False)
-        fetched_md5 = ChecksumCalculator.calculate(text_for_checksuming, ignore_whitespace=ignore_whitespace)
-
-        # === BLOCKING RULES EVALUATION ===
+        ############ Blocking rules, after checksum #################
         blocked = False
-
-        # Check trigger_text
-        if rule_engine.evaluate_trigger_text(stripped_text, filter_config.trigger_text):
+        trigger_text = list(dict.fromkeys(watch.get('trigger_text', []) + self.datastore.get_tag_overrides_for_watch(uuid=watch.get('uuid'), attr='trigger_text')))
+        if len(trigger_text):
+            # Assume blocked
             blocked = True
+            # Filter and trigger works the same, so reuse it
+            # It should return the line numbers that match
+            # Unblock flow if the trigger was found (some text remained after stripped what didnt match)
+            result = html_tools.strip_ignore_text(content=str(stripped_text_from_html),
+                                                  wordlist=trigger_text,
+                                                  mode="line numbers")
+            # Unblock if the trigger was found
+            if result:
+                blocked = False
 
-        # Check text_should_not_be_present
-        if rule_engine.evaluate_text_should_not_be_present(stripped_text, filter_config.text_should_not_be_present):
-            blocked = True
+        text_should_not_be_present = list(dict.fromkeys(watch.get('text_should_not_be_present', []) + self.datastore.get_tag_overrides_for_watch(uuid=watch.get('uuid'), attr='text_should_not_be_present')))
+        if len(text_should_not_be_present):
+            # If anything matched, then we should block a change from happening
+            result = html_tools.strip_ignore_text(content=str(stripped_text_from_html),
+                                                  wordlist=text_should_not_be_present,
+                                                  mode="line numbers")
+            if result:
+                blocked = True
 
-        # Check custom conditions
-        if rule_engine.evaluate_conditions(watch, self.datastore, stripped_text):
-            blocked = True
+        # And check if 'conditions' will let this pass through
+        if watch.get('conditions') and watch.get('conditions_match_logic'):
+            conditions_result = execute_ruleset_against_all_plugins(current_watch_uuid=watch.get('uuid'),
+                                                                    application_datastruct=self.datastore.data,
+                                                                    ephemeral_data={
+                                                                        'text': stripped_text_from_html
+                                                                    }
+                                                                    )
 
-        # === CHANGE DETECTION ===
+            if not conditions_result.get('result'):
+                # Conditions say "Condition not met" so we block it.
+                blocked = True
+
+        # Looks like something changed, but did it match all the rules?
         if blocked:
             changed_detected = False
         else:
-            # Compare checksums
+            # The main thing that all this at the moment comes down to :)
             if watch.get('previous_md5') != fetched_md5:
                 changed_detected = True
 
             # Always record the new checksum
             update_obj["previous_md5"] = fetched_md5
 
-            # On first run, initialize previous_md5
+            # On the first run of a site, watch['previous_md5'] will be None, set it the current one.
             if not watch.get('previous_md5'):
                 watch['previous_md5'] = fetched_md5
 
         logger.debug(f"Watch UUID {watch.get('uuid')} content check - Previous MD5: {watch.get('previous_md5')}, Fetched MD5 {fetched_md5}")
 
-        # === UNIQUE LINES CHECK ===
-        if changed_detected and watch.get('check_unique_lines', False):
-            has_unique_lines = watch.lines_contain_something_unique_compared_to_history(
-                lines=stripped_text.splitlines(),
-                ignore_whitespace=ignore_whitespace
-            )
+        if changed_detected:
+            if watch.get('check_unique_lines', False):
+                ignore_whitespace = self.datastore.data['settings']['application'].get('ignore_whitespace')
 
-            if not has_unique_lines:
-                logger.debug(f"check_unique_lines: UUID {watch.get('uuid')} didnt have anything new setting change_detected=False")
-                changed_detected = False
-            else:
-                logger.debug(f"check_unique_lines: UUID {watch.get('uuid')} had unique content")
+                has_unique_lines = watch.lines_contain_something_unique_compared_to_history(
+                    lines=stripped_text_from_html.splitlines(),
+                    ignore_whitespace=ignore_whitespace
+                )
 
-        return changed_detected, update_obj, stripped_text
+                # One or more lines? unsure?
+                if not has_unique_lines:
+                    logger.debug(f"check_unique_lines: UUID {watch.get('uuid')} didnt have anything new setting change_detected=False")
+                    changed_detected = False
+                else:
+                    logger.debug(f"check_unique_lines: UUID {watch.get('uuid')} had unique content")
 
-    def _apply_diff_filtering(self, watch, stripped_text, text_before_filter):
-        """Apply user's diff filtering preferences (show only added/removed/replaced lines)."""
-        from changedetectionio import diff
 
-        rendered_diff = diff.render_diff(
-            previous_version_file_contents=watch.get_last_fetched_text_before_filters(),
-            newest_version_file_contents=stripped_text,
-            include_equal=False,
-            include_added=watch.get('filter_text_added', True),
-            include_removed=watch.get('filter_text_removed', True),
-            include_replaced=watch.get('filter_text_replaced', True),
-            line_feed_sep="\n",
-            include_change_type_prefix=False
-        )
-
-        watch.save_last_text_fetched_before_filters(text_before_filter.encode('utf-8'))
-
-        if not rendered_diff and stripped_text:
-            # No differences found
-            return None
-
-        return rendered_diff
+        # stripped_text_from_html - Everything after filters and NO 'ignored' content
+        return changed_detected, update_obj, stripped_text_from_html

changedetectionio/realtime/socket_server.py

@@ -243,15 +243,14 @@ def handle_watch_update(socketio, **kwargs):
 
         general_stats = {
             'count_errors': errored_count,
-            'unread_changes_count': datastore.unread_changes_count
+            'has_unviewed': datastore.has_unviewed
         }
 
         # Debug what's being emitted
         # logger.debug(f"Emitting 'watch_update' event for {watch.get('uuid')}, data: {watch_data}")
 
         # Emit to all clients (no 'broadcast' parameter needed - it's the default behavior)
-        socketio.emit("watch_update", {'watch': watch_data})
-        socketio.emit("general_stats_update", general_stats)
+        socketio.emit("watch_update", {'watch': watch_data, 'general_stats': general_stats})
 
         # Log after successful emit - use watch_data['uuid'] to avoid variable shadowing issues
         logger.trace(f"Socket.IO: Emitted update for watch {watch_data['uuid']}, Checking now: {watch_data['checking_now']}")

changedetectionio/run_socks_proxy_tests.sh

@@ -9,7 +9,7 @@ set -x
 # SOCKS5 related - start simple Socks5 proxy server
 # SOCKSTEST=xyz should show in the logs of this service to confirm it fetched
 docker run --network changedet-network -d --hostname socks5proxy --rm  --name socks5proxy -p 1080:1080 -e PROXY_USER=proxy_user123 -e PROXY_PASSWORD=proxy_pass123 serjs/go-socks5-proxy
-docker run --network changedet-network -d --hostname socks5proxy-noauth --rm -p 1081:1080 --name socks5proxy-noauth -e REQUIRE_AUTH=false serjs/go-socks5-proxy
+docker run --network changedet-network -d --hostname socks5proxy-noauth --rm  -p 1081:1080 --name socks5proxy-noauth  serjs/go-socks5-proxy
 
 echo "---------------------------------- SOCKS5 -------------------"
 # SOCKS5 related - test from proxies.json

changedetectionio/static/js/realtime.js

@@ -117,16 +117,15 @@ $(document).ready(function () {
                 }
             })
 
-            socket.on('general_stats_update', function (general_stats) {
-                // Tabs at bottom of list
-                $('#watch-table-wrapper').toggleClass("has-unread-changes", general_stats.unread_changes_count !==0)
-                $('#watch-table-wrapper').toggleClass("has-error", general_stats.count_errors !== 0)
-                $('#post-list-with-errors a').text(`With errors (${ new Intl.NumberFormat(navigator.language).format(general_stats.count_errors) })`);
-                $('#unread-tab-counter').text(new Intl.NumberFormat(navigator.language).format(general_stats.unread_changes_count));
-            });
-
             socket.on('watch_update', function (data) {
                 const watch = data.watch;
+                const general_stats = data.general_stats;
+
+                // Log the entire watch object for debugging
+                console.log('!!! WATCH UPDATE EVENT RECEIVED !!!');
+                console.log(`${watch.event_timestamp} - Watch update ${watch.uuid} - Checking now - ${watch.checking_now} - UUID in URL ${window.location.href.includes(watch.uuid)}`);
+                console.log('Watch data:', watch);
+                console.log('General stats:', general_stats);
 
                 // Updating watch table rows
                 const $watchRow = $('tr[data-watch-uuid="' + watch.uuid + '"]');
@@ -151,6 +150,13 @@ $(document).ready(function () {
 
                     console.log('Updated UI for watch:', watch.uuid);
                 }
+
+                // Tabs at bottom of list
+                $('#post-list-mark-views').toggleClass("has-unviewed", general_stats.has_unviewed);
+                $('#post-list-unread').toggleClass("has-unviewed", general_stats.has_unviewed);
+                $('#post-list-with-errors').toggleClass("has-error", general_stats.count_errors !== 0)
+                $('#post-list-with-errors a').text(`With errors (${ general_stats.count_errors })`);
+
                 $('body').toggleClass('checking-now', watch.checking_now && window.location.href.includes(watch.uuid));
             });
 

changedetectionio/static/styles/scss/parts/_socket.scss

@@ -17,6 +17,18 @@ body.checking-now {
   position: fixed;
 }
 
+#post-list-buttons {
+  #post-list-with-errors.has-error {
+    display: inline-block !important;
+  }
+  #post-list-mark-views.has-unviewed {
+    display: inline-block !important;
+  }
+  #post-list-unread.has-unviewed {
+    display: inline-block !important;
+  }
+}
+
 
 
 

changedetectionio/static/styles/scss/parts/_watch_table.scss

@@ -127,44 +127,5 @@
       display: inline-block !important;
     }
   }
-
-
 }
 
-#watch-table-wrapper {
-  /* general styling */
-  #post-list-buttons {
-    text-align: right;
-    padding: 0px;
-    margin: 0px;
-
-    li {
-      display: inline-block;
-    }
-
-    a {
-      border-top-left-radius: initial;
-      border-top-right-radius: initial;
-      border-bottom-left-radius: 5px;
-      border-bottom-right-radius: 5px;
-    }
-  }
-
-  /* post list dynamically on/off stuff */
-
-  &.has-error {
-    #post-list-buttons {
-      #post-list-with-errors {
-        display: inline-block !important;
-      }
-    }
-  }
-
-  &.has-unread-changes {
-    #post-list-buttons {
-      #post-list-unread, #post-list-mark-views, #post-list-unread {
-        display: inline-block !important;
-      }
-    }
-  }
-}

changedetectionio/static/styles/scss/parts/_widgets.scss

@@ -34,6 +34,7 @@
       transition: all 0.2s ease;
       cursor: pointer;
       display: block;
+      min-width: 60px;
       text-align: center;
     }
 

changedetectionio/static/styles/scss/styles.scss

@@ -203,6 +203,24 @@ code {
 }
 
 
+#post-list-buttons {
+  text-align: right;
+  padding: 0px;
+  margin: 0px;
+
+  li {
+    display: inline-block;
+  }
+
+  a {
+    border-top-left-radius: initial;
+    border-top-right-radius: initial;
+    border-bottom-left-radius: 5px;
+    border-bottom-right-radius: 5px;
+  }
+}
+
+
 body:after {
   content: "";
   background: linear-gradient(130deg, var(--color-background-gradient-first), var(--color-background-gradient-second) 41.07%, var(--color-background-gradient-third) 84.05%);

changedetectionio/store.py

@@ -202,13 +202,14 @@ class ChangeDetectionStore:
         return seconds
 
     @property
-    def unread_changes_count(self):
-        unread_changes_count = 0
+    def has_unviewed(self):
+        if not self.__data.get('watching'):
+            return None
+
         for uuid, watch in self.__data['watching'].items():
             if watch.history_n >= 2 and watch.viewed == False:
-                unread_changes_count += 1
-
-        return unread_changes_count
+                return True
+        return False
 
     @property
     def data(self):

changedetectionio/templates/_helpers.html

@@ -1,29 +1,14 @@
 {% macro render_field(field) %}
-    <div {% if field.errors or field.top_errors %} class="error" {% endif %}>{{ field.label }}</div>
-    <div {% if field.errors or field.top_errors %} class="error" {% endif %}>{{ field(**kwargs)|safe }}
-        {% if field.top_errors %}
-            top
-            <ul class="errors top-errors">
-                {% for error in field.top_errors %}
-                    <li>{{ error }}</li>
-                {% endfor %}
-            </ul>
-        {% endif %}
-        {% if field.errors %}
-            <ul class=errors>
-                {% if field.errors is mapping and 'form' in field.errors %}
-                    {#  and subfield form errors, such as used in RequiredFormField() for TimeBetweenCheckForm sub form #}
-                    {% set errors = field.errors['form'] %}
-                {% else %}
-                    {#  regular list of errors with this field #}
-                    {% set errors = field.errors %}
-                {% endif %}
-                {% for error in errors %}
-                    <li>{{ error }}</li>
-                {% endfor %}
-            </ul>
-        {% endif %}
-    </div>
+  <div {% if field.errors %} class="error" {% endif %}>{{ field.label }}</div>
+  <div {% if field.errors %} class="error" {% endif %}>{{ field(**kwargs)|safe }}
+  {% if field.errors %}
+    <ul class=errors>
+    {% for error in field.errors %}
+      <li>{{ error }}</li>
+    {% endfor %}
+    </ul>
+  {% endif %}
+  </div>
 {% endmacro %}
 
 {% macro render_checkbox_field(field) %}

changedetectionio/templates/base.html

@@ -5,7 +5,6 @@
     <meta charset="utf-8" >
     <meta name="viewport" content="width=device-width, initial-scale=1.0" >
     <meta name="description" content="Self hosted website change detection." >
-    <meta name="robots" content="noindex">
     <title>Change Detection{{extra_title}}</title>
     {% if app_rss_token %}
       <link rel="alternate" type="application/rss+xml" title="Changedetection.io » Feed{% if active_tag_uuid %}- {{active_tag.title}}{% endif %}" href="{{ url_for('rss.feed', tag=active_tag_uuid , token=app_rss_token)}}" >
@@ -41,7 +40,7 @@
     {% endif %}
   </head>
 
-  <body class="{{extra_classes}}">
+  <body class="">
     <div class="header">
     <div class="pure-menu-fixed" style="width: 100%;">
       <div class="home-menu pure-menu pure-menu-horizontal" id="nav-menu">

changedetectionio/templates/edit/text-options.html

@@ -26,10 +26,7 @@
                             <li>Changing this will affect the comparison checksum which may trigger an alert</li>
                         </ul>
                 </span>
-                <br><br>
-                    <div class="pure-control-group">
-                      {{ render_ternary_field(form.strip_ignored_lines) }}
-                    </div>
+
                 </fieldset>
 
                 <fieldset>

changedetectionio/tests/conftest.py

@@ -29,28 +29,16 @@ def reportlog(pytestconfig):
     logger.remove(handler_id)
 
 
-def format_memory_human(bytes_value):
-    """Format memory in human-readable units (KB, MB, GB)"""
-    if bytes_value < 1024:
-        return f"{bytes_value} B"
-    elif bytes_value < 1024 ** 2:
-        return f"{bytes_value / 1024:.2f} KB"
-    elif bytes_value < 1024 ** 3:
-        return f"{bytes_value / (1024 ** 2):.2f} MB"
-    else:
-        return f"{bytes_value / (1024 ** 3):.2f} GB"
-
 def track_memory(memory_usage, ):
     process = psutil.Process(os.getpid())
     while not memory_usage["stop"]:
         current_rss = process.memory_info().rss
         memory_usage["peak"] = max(memory_usage["peak"], current_rss)
-        memory_usage["current"] = current_rss  # Keep updating current
         time.sleep(0.01)  # Adjust the sleep time as needed
 
 @pytest.fixture(scope='function')
 def measure_memory_usage(request):
-    memory_usage = {"peak": 0, "current": 0, "stop": False}
+    memory_usage = {"peak": 0, "stop": False}
     tracker_thread = Thread(target=track_memory, args=(memory_usage,))
     tracker_thread.start()
 
@@ -59,17 +47,16 @@ def measure_memory_usage(request):
     memory_usage["stop"] = True
     tracker_thread.join()
 
-    # Note: psutil returns RSS memory in bytes
-    peak_human = format_memory_human(memory_usage["peak"])
-
-    s = f"{time.time()} {request.node.fspath} - '{request.node.name}' - Peak memory: {peak_human}"
+    # Note: ru_maxrss is in kilobytes on Unix-based systems
+    max_memory_used = memory_usage["peak"] / 1024  # Convert to MB
+    s = f"Peak memory used by the test {request.node.fspath} - '{request.node.name}': {max_memory_used:.2f} MB"
     logger.debug(s)
 
     with open("test-memory.log", 'a') as f:
         f.write(f"{s}\n")
 
     # Assert that the memory usage is less than 200MB
-#    assert peak_memory_kb < 150 * 1024, f"Memory usage exceeded 150MB: {peak_human}"
+#    assert max_memory_used < 150, f"Memory usage exceeded 200MB: {max_memory_used:.2f} MB"
 
 
 def cleanup(datastore_path):

changedetectionio/tests/custom_browser_url/test_custom_browser_url.py

@@ -29,8 +29,13 @@ def do_test(client, live_server, make_test_use_extra_browser=False):
     assert b"Settings updated." in res.data
 
     # Add our URL to the import page
-    uuid = client.application.config.get('DATASTORE').add_watch(url=test_url)
-    client.get(url_for("ui.form_watch_checknow"), follow_redirects=True)
+    res = client.post(
+        url_for("imports.import_page"),
+        data={"urls": test_url},
+        follow_redirects=True
+    )
+
+    assert b"1 Imported" in res.data
     wait_for_all_checks(client)
 
     if make_test_use_extra_browser:
@@ -50,8 +55,7 @@ def do_test(client, live_server, make_test_use_extra_browser=False):
                   "tags": "",
                   "headers": "",
                   'fetch_backend': f"extra_browser_{custom_browser_name}",
-                  'webdriver_js_execute_code': '',
-                  "time_between_check_use_default": "y"
+                  'webdriver_js_execute_code': ''
             },
             follow_redirects=True
         )

changedetectionio/tests/fetchers/test_custom_js_before_content.py

@@ -28,7 +28,6 @@ def test_execute_custom_js(client, live_server, measure_memory_usage):
             'fetch_backend': "html_webdriver",
             'webdriver_js_execute_code': 'document.querySelector("button[name=test-button]").click();',
             'headers': "testheader: yes\buser-agent: MyCustomAgent",
-            "time_between_check_use_default": "y",
         },
         follow_redirects=True
     )

changedetectionio/tests/proxy_list/test_multiple_proxy.py

@@ -27,7 +27,6 @@ def test_preferred_proxy(client, live_server, measure_memory_usage):
                 "proxy": "proxy-two",
                 "tags": "",
                 "url": url,
-                "time_between_check_use_default": "y",
               },
         follow_redirects=True
     )

changedetectionio/tests/proxy_list/test_noproxy.py

@@ -62,7 +62,6 @@ def test_noproxy_option(client, live_server, measure_memory_usage):
                 "proxy": "no-proxy",
                 "tags": "",
                 "url": url,
-                "time_between_check_use_default": "y",
               },
         follow_redirects=True
     )

changedetectionio/tests/proxy_list/test_proxy_noconnect.py

@@ -44,7 +44,6 @@ def test_proxy_noconnect_custom(client, live_server, measure_memory_usage):
         "url": test_url,
         "fetch_backend": "html_webdriver" if os.getenv('PLAYWRIGHT_DRIVER_URL') or os.getenv("WEBDRIVER_URL") else "html_requests",
         "proxy": "ui-0custom-test-proxy",
-        "time_between_check_use_default": "y",
     }
 
     res = client.post(

changedetectionio/tests/proxy_socks5/test_socks5_proxy.py

@@ -2,7 +2,7 @@
 import json
 import os
 from flask import url_for
-from changedetectionio.tests.util import live_server_setup, wait_for_all_checks, extract_UUID_from_client, delete_all_watches
+from changedetectionio.tests.util import live_server_setup, wait_for_all_checks, extract_UUID_from_client
 
 
 def set_response():
@@ -66,7 +66,6 @@ def test_socks5(client, live_server, measure_memory_usage):
             "proxy": "ui-0socks5proxy",
             "tags": "",
             "url": test_url,
-            "time_between_check_use_default": "y",
         },
         follow_redirects=True
     )
@@ -98,5 +97,6 @@ def test_socks5(client, live_server, measure_memory_usage):
     )
     assert b"OK" in res.data
 
-    delete_all_watches(client)
+    res = client.get(url_for("ui.form_delete", uuid="all"), follow_redirects=True)
+    assert b'Deleted' in res.data
 

changedetectionio/tests/proxy_socks5/test_socks5_proxy_sources.py

@@ -53,7 +53,6 @@ def test_socks5_from_proxiesjson_file(client, live_server, measure_memory_usage)
             "proxy": "socks5proxy",
             "tags": "",
             "url": test_url,
-            "time_between_check_use_default": "y",
         },
         follow_redirects=True
     )

changedetectionio/tests/smtp/test_notification_smtp.py

@@ -5,7 +5,7 @@ import re
 from flask import url_for
 from changedetectionio.tests.util import set_original_response, set_modified_response, set_more_modified_response, live_server_setup, \
     wait_for_all_checks, \
-    set_longer_modified_response, delete_all_watches
+    set_longer_modified_response
 from changedetectionio.tests.util import extract_UUID_from_client
 import logging
 import base64
@@ -85,7 +85,8 @@ def test_check_notification_email_formats_default_HTML(client, live_server, meas
     assert '(added) So let\'s see what happens.\r\n' in msg  # The plaintext part with \r\n
     assert 'Content-Type: text/html' in msg
     assert '(added) So let\'s see what happens.<br>' in msg  # the html part
-    delete_all_watches(client)
+    res = client.get(url_for("ui.form_delete", uuid="all"), follow_redirects=True)
+    assert b'Deleted' in res.data
 
 
 def test_check_notification_email_formats_default_Text_override_HTML(client, live_server, measure_memory_usage):
@@ -156,8 +157,7 @@ def test_check_notification_email_formats_default_Text_override_HTML(client, liv
         data={
             "url": test_url,
             "notification_format": 'HTML',
-            'fetch_backend': "html_requests",
-            "time_between_check_use_default": "y"},
+            'fetch_backend': "html_requests"},
         follow_redirects=True
     )
     assert b"Updated watch." in res.data
@@ -178,4 +178,5 @@ def test_check_notification_email_formats_default_Text_override_HTML(client, liv
     assert '&lt;' not in msg
     assert 'Content-Type: text/html' in msg
 
-    delete_all_watches(client)
+    res = client.get(url_for("ui.form_delete", uuid="all"), follow_redirects=True)
+    assert b'Deleted' in res.data

changedetectionio/tests/test_access_control.py

@@ -2,7 +2,7 @@ from .util import live_server_setup, wait_for_all_checks
 from flask import url_for
 import time
 
-def test_check_access_control(app, client, live_server, measure_memory_usage):
+def test_check_access_control(app, client, live_server):
     # Still doesnt work, but this is closer.
    #  live_server_setup(live_server) # Setup on conftest per function
 

changedetectionio/tests/test_add_replace_remove_filter.py

@@ -3,7 +3,7 @@
 import os.path
 
 from flask import url_for
-from .util import live_server_setup, wait_for_all_checks, wait_for_notification_endpoint_output, delete_all_watches
+from .util import live_server_setup, wait_for_all_checks, wait_for_notification_endpoint_output
 import time
 
 def set_original(excluding=None, add_line=None):
@@ -44,8 +44,12 @@ def test_check_removed_line_contains_trigger(client, live_server, measure_memory
     set_original()
     # Add our URL to the import page
     test_url = url_for('test_endpoint', _external=True)
-    uuid = client.application.config.get('DATASTORE').add_watch(url=test_url)
-    client.get(url_for("ui.form_watch_checknow"), follow_redirects=True)
+    res = client.post(
+        url_for("imports.import_page"),
+        data={"urls": test_url},
+        follow_redirects=True
+    )
+    assert b"1 Imported" in res.data
 
     # Give the thread time to pick it up
     wait_for_all_checks(client)
@@ -57,8 +61,7 @@ def test_check_removed_line_contains_trigger(client, live_server, measure_memory
         data={"trigger_text": 'The golden line',
               "url": test_url,
               'fetch_backend': "html_requests",
-              'filter_text_removed': 'y',
-              "time_between_check_use_default": "y"},
+              'filter_text_removed': 'y'},
         follow_redirects=True
     )
     assert b"Updated watch." in res.data
@@ -71,7 +74,7 @@ def test_check_removed_line_contains_trigger(client, live_server, measure_memory
     wait_for_all_checks(client)
     time.sleep(0.5)
     res = client.get(url_for("watchlist.index"))
-    assert b'has-unread-changes' not in res.data
+    assert b'unviewed' not in res.data
 
     # The trigger line is REMOVED,  this should trigger
     set_original(excluding='The golden line')
@@ -80,7 +83,7 @@ def test_check_removed_line_contains_trigger(client, live_server, measure_memory
     client.get(url_for("ui.form_watch_checknow"), follow_redirects=True)
     wait_for_all_checks(client)
     res = client.get(url_for("watchlist.index"))
-    assert b'has-unread-changes' in res.data
+    assert b'unviewed' in res.data
 
     time.sleep(1)
 
@@ -94,21 +97,23 @@ def test_check_removed_line_contains_trigger(client, live_server, measure_memory
     wait_for_all_checks(client)
     time.sleep(1)
     res = client.get(url_for("watchlist.index"))
-    assert b'has-unread-changes' not in res.data
+    assert b'unviewed' not in res.data
 
     # Remove it again, and we should get a trigger
     set_original(excluding='The golden line')
     client.get(url_for("ui.form_watch_checknow"), follow_redirects=True)
     wait_for_all_checks(client)
     res = client.get(url_for("watchlist.index"))
-    assert b'has-unread-changes' in res.data
+    assert b'unviewed' in res.data
 
-    delete_all_watches(client)
+    res = client.get(url_for("ui.form_delete", uuid="all"), follow_redirects=True)
+    assert b'Deleted' in res.data
 
 
 def test_check_add_line_contains_trigger(client, live_server, measure_memory_usage):
     
-    delete_all_watches(client)
+    res = client.get(url_for("ui.form_delete", uuid="all"), follow_redirects=True)
+    assert b'Deleted' in res.data
     time.sleep(1)
 
     # Give the endpoint time to spin up
@@ -131,8 +136,12 @@ def test_check_add_line_contains_trigger(client, live_server, measure_memory_usa
     set_original()
     # Add our URL to the import page
     test_url = url_for('test_endpoint', _external=True)
-    uuid = client.application.config.get('DATASTORE').add_watch(url=test_url)
-    client.get(url_for("ui.form_watch_checknow"), follow_redirects=True)
+    res = client.post(
+        url_for("imports.import_page"),
+        data={"urls": test_url},
+        follow_redirects=True
+    )
+    assert b"1 Imported" in res.data
 
     # Give the thread time to pick it up
     wait_for_all_checks(client)
@@ -145,8 +154,7 @@ def test_check_add_line_contains_trigger(client, live_server, measure_memory_usa
               'processor': 'text_json_diff',
               'fetch_backend': "html_requests",
               'filter_text_removed': '',
-              'filter_text_added': 'y',
-              "time_between_check_use_default": "y"},
+              'filter_text_added': 'y'},
         follow_redirects=True
     )
     assert b"Updated watch." in res.data
@@ -159,7 +167,7 @@ def test_check_add_line_contains_trigger(client, live_server, measure_memory_usa
 
     wait_for_all_checks(client)
     res = client.get(url_for("watchlist.index"))
-    assert b'has-unread-changes' not in res.data
+    assert b'unviewed' not in res.data
 
     # The trigger line is ADDED,  this should trigger
     set_original(add_line='<p>Oh yes please</p>')
@@ -167,7 +175,7 @@ def test_check_add_line_contains_trigger(client, live_server, measure_memory_usa
     wait_for_all_checks(client)
     res = client.get(url_for("watchlist.index"))
 
-    assert b'has-unread-changes' in res.data
+    assert b'unviewed' in res.data
 
     # Takes a moment for apprise to fire
     wait_for_notification_endpoint_output()
@@ -177,4 +185,5 @@ def test_check_add_line_contains_trigger(client, live_server, measure_memory_usa
         assert b'-Oh yes please' in response
         assert '网站监测 内容更新了'.encode('utf-8') in response
 
-    delete_all_watches(client)
+    res = client.get(url_for("ui.form_delete", uuid="all"), follow_redirects=True)
+    assert b'Deleted' in res.data

changedetectionio/tests/test_api.py

@@ -2,7 +2,7 @@
 
 import time
 from flask import url_for
-from .util import live_server_setup, wait_for_all_checks, delete_all_watches
+from .util import live_server_setup, wait_for_all_checks
 
 import json
 import uuid
@@ -276,7 +276,8 @@ def test_access_denied(client, live_server, measure_memory_usage):
     assert res.status_code == 200
 
     # Cleanup everything
-    delete_all_watches(client)
+    res = client.get(url_for("ui.form_delete", uuid="all"), follow_redirects=True)
+    assert b'Deleted' in res.data
 
     res = client.post(
         url_for("settings.settings_page"),
@@ -384,7 +385,8 @@ def test_api_watch_PUT_update(client, live_server, measure_memory_usage):
     assert b'Additional properties are not allowed' in res.data
 
     # Cleanup everything
-    delete_all_watches(client)
+    res = client.get(url_for("ui.form_delete", uuid="all"), follow_redirects=True)
+    assert b'Deleted' in res.data
 
 
 def test_api_import(client, live_server, measure_memory_usage):
@@ -394,7 +396,7 @@ def test_api_import(client, live_server, measure_memory_usage):
     res = client.post(
         url_for("import") + "?tag=import-test",
         data='https://website1.com\r\nhttps://website2.com',
-        headers={'x-api-key': api_key, 'content-type': 'text/plain'},
+        headers={'x-api-key': api_key},
         follow_redirects=True
     )
 

changedetectionio/tests/test_api_notifications.py

@@ -4,7 +4,7 @@ from flask import url_for
 from .util import live_server_setup
 import json
 
-def test_api_notifications_crud(client, live_server, measure_memory_usage):
+def test_api_notifications_crud(client, live_server):
    #  live_server_setup(live_server) # Setup on conftest per function
     api_key = live_server.app.config['DATASTORE'].data['settings']['application'].get('api_access_token')
 

changedetectionio/tests/test_api_openapi.py

@@ -1,199 +0,0 @@
-#!/usr/bin/env python3
-"""
-OpenAPI validation tests for ChangeDetection.io API
-
-This test file specifically verifies that OpenAPI validation is working correctly
-by testing various scenarios that should trigger validation errors.
-"""
-
-import time
-import json
-from flask import url_for
-from .util import live_server_setup, wait_for_all_checks
-
-
-def test_openapi_validation_invalid_content_type_on_create_watch(client, live_server, measure_memory_usage):
-    """Test that creating a watch with invalid content-type triggers OpenAPI validation error."""
-    api_key = live_server.app.config['DATASTORE'].data['settings']['application'].get('api_access_token')
-
-    # Try to create a watch with JSON data but without proper content-type header
-    res = client.post(
-        url_for("createwatch"),
-        data=json.dumps({"url": "https://example.com", "title": "Test Watch"}),
-        headers={'x-api-key': api_key},  # Missing 'content-type': 'application/json'
-        follow_redirects=True
-    )
-
-    # Should get 400 error due to OpenAPI validation failure
-    assert res.status_code == 400, f"Expected 400 but got {res.status_code}"
-    assert b"OpenAPI validation failed" in res.data, "Should contain OpenAPI validation error message"
-
-
-def test_openapi_validation_missing_required_field_create_watch(client, live_server, measure_memory_usage):
-    """Test that creating a watch without required URL field triggers OpenAPI validation error."""
-    api_key = live_server.app.config['DATASTORE'].data['settings']['application'].get('api_access_token')
-
-    # Try to create a watch without the required 'url' field
-    res = client.post(
-        url_for("createwatch"),
-        data=json.dumps({"title": "Test Watch Without URL"}),  # Missing required 'url' field
-        headers={'x-api-key': api_key, 'content-type': 'application/json'},
-        follow_redirects=True
-    )
-
-    # Should get 400 error due to missing required field
-    assert res.status_code == 400, f"Expected 400 but got {res.status_code}"
-    assert b"OpenAPI validation failed" in res.data, "Should contain OpenAPI validation error message"
-
-
-def test_openapi_validation_invalid_field_in_request_body(client, live_server, measure_memory_usage):
-    """Test that including invalid fields triggers OpenAPI validation error."""
-    api_key = live_server.app.config['DATASTORE'].data['settings']['application'].get('api_access_token')
-
-    # First create a valid watch
-    res = client.post(
-        url_for("createwatch"),
-        data=json.dumps({"url": "https://example.com", "title": "Test Watch"}),
-        headers={'x-api-key': api_key, 'content-type': 'application/json'},
-        follow_redirects=True
-    )
-    assert res.status_code == 201, "Watch creation should succeed"
-
-    # Get the watch list to find the UUID
-    res = client.get(
-        url_for("createwatch"),
-        headers={'x-api-key': api_key}
-    )
-    assert res.status_code == 200
-    watch_uuid = list(res.json.keys())[0]
-
-    # Now try to update the watch with an invalid field
-    res = client.put(
-        url_for("watch", uuid=watch_uuid),
-        headers={'x-api-key': api_key, 'content-type': 'application/json'},
-        data=json.dumps({
-            "title": "Updated title",
-            "invalid_field_that_doesnt_exist": "this should cause validation error"
-        }),
-    )
-
-    # Should get 400 error due to invalid field (this will be caught by internal validation)
-    # Note: This tests the flow where OpenAPI validation passes but internal validation catches it
-    assert res.status_code == 400, f"Expected 400 but got {res.status_code}"
-    assert b"Additional properties are not allowed" in res.data, "Should contain validation error about additional properties"
-
-
-def test_openapi_validation_import_wrong_content_type(client, live_server, measure_memory_usage):
-    """Test that import endpoint with wrong content-type triggers OpenAPI validation error."""
-    api_key = live_server.app.config['DATASTORE'].data['settings']['application'].get('api_access_token')
-
-    # Try to import URLs with JSON content-type instead of text/plain
-    res = client.post(
-        url_for("import") + "?tag=test-import",
-        data='https://website1.com\nhttps://website2.com',
-        headers={'x-api-key': api_key, 'content-type': 'application/json'},  # Wrong content-type
-        follow_redirects=True
-    )
-
-    # Should get 400 error due to content-type mismatch
-    assert res.status_code == 400, f"Expected 400 but got {res.status_code}"
-    assert b"OpenAPI validation failed" in res.data, "Should contain OpenAPI validation error message"
-
-
-def test_openapi_validation_import_correct_content_type_succeeds(client, live_server, measure_memory_usage):
-    """Test that import endpoint with correct content-type succeeds (positive test)."""
-    api_key = live_server.app.config['DATASTORE'].data['settings']['application'].get('api_access_token')
-
-    # Import URLs with correct text/plain content-type
-    res = client.post(
-        url_for("import") + "?tag=test-import",
-        data='https://website1.com\nhttps://website2.com',
-        headers={'x-api-key': api_key, 'content-type': 'text/plain'},  # Correct content-type
-        follow_redirects=True
-    )
-
-    # Should succeed
-    assert res.status_code == 200, f"Expected 200 but got {res.status_code}"
-    assert len(res.json) == 2, "Should import 2 URLs"
-
-
-def test_openapi_validation_get_requests_bypass_validation(client, live_server, measure_memory_usage):
-    """Test that GET requests bypass OpenAPI validation entirely."""
-    api_key = live_server.app.config['DATASTORE'].data['settings']['application'].get('api_access_token')
-
-    # Disable API token requirement first
-    res = client.post(
-        url_for("settings.settings_page"),
-        data={
-            "requests-time_between_check-minutes": 180,
-            "application-fetch_backend": "html_requests",
-            "application-api_access_token_enabled": ""
-        },
-        follow_redirects=True
-    )
-    assert b"Settings updated." in res.data
-
-    # Make GET request to list watches - should succeed even without API key or content-type
-    res = client.get(url_for("createwatch"))  # No headers needed for GET
-    assert res.status_code == 200, f"GET requests should succeed without OpenAPI validation, got {res.status_code}"
-
-    # Should return JSON with watch list (empty in this case)
-    assert isinstance(res.json, dict), "Should return JSON dictionary for watch list"
-
-
-def test_openapi_validation_create_tag_missing_required_title(client, live_server, measure_memory_usage):
-    """Test that creating a tag without required title triggers OpenAPI validation error."""
-    api_key = live_server.app.config['DATASTORE'].data['settings']['application'].get('api_access_token')
-
-    # Try to create a tag without the required 'title' field
-    res = client.post(
-        url_for("tag"),
-        data=json.dumps({"notification_urls": ["mailto:test@example.com"]}),  # Missing required 'title' field
-        headers={'x-api-key': api_key, 'content-type': 'application/json'},
-        follow_redirects=True
-    )
-
-    # Should get 400 error due to missing required field
-    assert res.status_code == 400, f"Expected 400 but got {res.status_code}"
-    assert b"OpenAPI validation failed" in res.data, "Should contain OpenAPI validation error message"
-
-
-def test_openapi_validation_watch_update_allows_partial_updates(client, live_server, measure_memory_usage):
-    """Test that watch updates allow partial updates without requiring all fields (positive test)."""
-    api_key = live_server.app.config['DATASTORE'].data['settings']['application'].get('api_access_token')
-
-    # First create a valid watch
-    res = client.post(
-        url_for("createwatch"),
-        data=json.dumps({"url": "https://example.com", "title": "Test Watch"}),
-        headers={'x-api-key': api_key, 'content-type': 'application/json'},
-        follow_redirects=True
-    )
-    assert res.status_code == 201, "Watch creation should succeed"
-
-    # Get the watch list to find the UUID
-    res = client.get(
-        url_for("createwatch"),
-        headers={'x-api-key': api_key}
-    )
-    assert res.status_code == 200
-    watch_uuid = list(res.json.keys())[0]
-
-    # Update only the title (partial update) - should succeed
-    res = client.put(
-        url_for("watch", uuid=watch_uuid),
-        headers={'x-api-key': api_key, 'content-type': 'application/json'},
-        data=json.dumps({"title": "Updated Title Only"}),  # Only updating title, not URL
-    )
-
-    # Should succeed because UpdateWatch schema allows partial updates
-    assert res.status_code == 200, f"Partial updates should succeed, got {res.status_code}"
-
-    # Verify the update worked
-    res = client.get(
-        url_for("watch", uuid=watch_uuid),
-        headers={'x-api-key': api_key}
-    )
-    assert res.status_code == 200
-    assert res.json.get('title') == 'Updated Title Only', "Title should be updated"
-    assert res.json.get('url') == 'https://example.com', "URL should remain unchanged"

changedetectionio/tests/test_api_search.py

@@ -6,7 +6,7 @@ import time
 from .util import live_server_setup, wait_for_all_checks
 
 
-def test_api_search(client, live_server, measure_memory_usage):
+def test_api_search(client, live_server):
    #  live_server_setup(live_server) # Setup on conftest per function
     api_key = live_server.app.config['DATASTORE'].data['settings']['application'].get('api_access_token')
 

changedetectionio/tests/test_auth.py

@@ -12,14 +12,18 @@ def test_basic_auth(client, live_server, measure_memory_usage):
     # This page will echo back any auth info
     test_url = url_for('test_basicauth_method', _external=True).replace("//","//myuser:mypass@")
     time.sleep(1)
-    uuid = client.application.config.get('DATASTORE').add_watch(url=test_url)
-    client.get(url_for("ui.form_watch_checknow"), follow_redirects=True)
+    res = client.post(
+        url_for("imports.import_page"),
+        data={"urls": test_url},
+        follow_redirects=True
+    )
+    assert b"1 Imported" in res.data
     wait_for_all_checks(client)
     time.sleep(1)
     # Check form validation
     res = client.post(
         url_for("ui.ui_edit.edit_page", uuid="first"),
-        data={"include_filters": "", "url": test_url, "tags": "", "headers": "", 'fetch_backend': "html_requests", "time_between_check_use_default": "y"},
+        data={"include_filters": "", "url": test_url, "tags": "", "headers": "", 'fetch_backend': "html_requests"},
         follow_redirects=True
     )
     assert b"Updated watch." in res.data

changedetectionio/tests/test_automatic_follow_ldjson_price.py

@@ -86,8 +86,12 @@ def test_check_ldjson_price_autodetect(client, live_server, measure_memory_usage
 
     # Add our URL to the import page
     test_url = url_for('test_endpoint', _external=True)
-    uuid = client.application.config.get('DATASTORE').add_watch(url=test_url)
-    client.get(url_for("ui.form_watch_checknow"), follow_redirects=True)
+    res = client.post(
+        url_for("imports.import_page"),
+        data={"urls": test_url},
+        follow_redirects=True
+    )
+    assert b"1 Imported" in res.data
     wait_for_all_checks(client)
 
     # Should get a notice that it's available
@@ -125,8 +129,12 @@ def test_check_ldjson_price_autodetect(client, live_server, measure_memory_usage
 
     # Add our URL to the import page
     test_url = url_for('test_endpoint', _external=True)
-    uuid = client.application.config.get('DATASTORE').add_watch(url=test_url)
-    client.get(url_for("ui.form_watch_checknow"), follow_redirects=True)
+    res = client.post(
+        url_for("imports.import_page"),
+        data={"urls": test_url},
+        follow_redirects=True
+    )
+    assert b"1 Imported" in res.data
     wait_for_all_checks(client)
     res = client.get(url_for("watchlist.index"))
     assert b'ldjson-price-track-offer' not in res.data
@@ -138,8 +146,12 @@ def test_check_ldjson_price_autodetect(client, live_server, measure_memory_usage
 def _test_runner_check_bad_format_ignored(live_server, client, has_ldjson_price_data):
 
     test_url = url_for('test_endpoint', _external=True)
-    uuid = client.application.config.get('DATASTORE').add_watch(url=test_url)
-    client.get(url_for("ui.form_watch_checknow"), follow_redirects=True)
+    res = client.post(
+        url_for("imports.import_page"),
+        data={"urls": test_url},
+        follow_redirects=True
+    )
+    assert b"1 Imported" in res.data
     wait_for_all_checks(client)
 
     for k,v in client.application.config.get('DATASTORE').data['watching'].items():

changedetectionio/tests/test_backend.py

@@ -3,7 +3,7 @@
 import time
 from flask import url_for
 from .util import set_original_response, set_modified_response, live_server_setup, wait_for_all_checks, extract_rss_token_from_UI, \
-    extract_UUID_from_client, delete_all_watches
+    extract_UUID_from_client
 
 sleep_time_for_fetch_thread = 3
 
@@ -38,9 +38,9 @@ def test_check_basic_change_detection_functionality(client, live_server, measure
         # Give the thread time to pick it up
         wait_for_all_checks(client)
 
-        # It should report nothing found (no new 'has-unread-changes' class)
+        # It should report nothing found (no new 'unviewed' class)
         res = client.get(url_for("watchlist.index"))
-        assert b'has-unread-changes' not in res.data
+        assert b'unviewed' not in res.data
         assert b'test-endpoint' in res.data
 
         # Default no password set, this stuff should be always available.
@@ -74,9 +74,9 @@ def test_check_basic_change_detection_functionality(client, live_server, measure
     res = client.get(url_for("ui.ui_edit.watch_get_latest_html", uuid=uuid))
     assert b'which has this one new line' in res.data
 
-    # Now something should be ready, indicated by having a 'has-unread-changes' class
+    # Now something should be ready, indicated by having a 'unviewed' class
     res = client.get(url_for("watchlist.index"))
-    assert b'has-unread-changes' in res.data
+    assert b'unviewed' in res.data
 
     # #75, and it should be in the RSS feed
     rss_token = extract_rss_token_from_UI(client)
@@ -90,7 +90,7 @@ def test_check_basic_change_detection_functionality(client, live_server, measure
 
     assert expected_url.encode('utf-8') in res.data
 #
-    # Following the 'diff' link, it should no longer display as 'has-unread-changes' even after we recheck it a few times
+    # Following the 'diff' link, it should no longer display as 'unviewed' even after we recheck it a few times
     res = client.get(url_for("ui.ui_views.diff_history_page", uuid=uuid))
     assert b'selected=""' in res.data, "Confirm diff history page loaded"
 
@@ -111,12 +111,12 @@ def test_check_basic_change_detection_functionality(client, live_server, measure
         # Give the thread time to pick it up
         wait_for_all_checks(client)
 
-        # It should report nothing found (no new 'has-unread-changes' class)
+        # It should report nothing found (no new 'unviewed' class)
         res = client.get(url_for("watchlist.index"))
 
 
-        assert b'has-unread-changes' not in res.data
-        assert b'class="has-unread-changes' not in res.data
+        assert b'unviewed' not in res.data
+        assert b'class="has-unviewed' not in res.data
         assert b'head title' in res.data  # Should be ON by default
         assert b'test-endpoint' in res.data
 
@@ -140,8 +140,8 @@ def test_check_basic_change_detection_functionality(client, live_server, measure
     wait_for_all_checks(client)
 
     res = client.get(url_for("watchlist.index"))
-    assert b'has-unread-changes' in res.data
-    assert b'class="has-unread-changes' in res.data
+    assert b'unviewed' in res.data
+    assert b'class="has-unviewed' in res.data
     assert b'head title' not in res.data  # should now be off
 
 
@@ -151,8 +151,8 @@ def test_check_basic_change_detection_functionality(client, live_server, measure
     # hit the mark all viewed link
     res = client.get(url_for("ui.mark_all_viewed"), follow_redirects=True)
 
-    assert b'class="has-unread-changes' not in res.data
-    assert b'has-unread-changes' not in res.data
+    assert b'class="has-unviewed' not in res.data
+    assert b'unviewed' not in res.data
 
     # #2458 "clear history" should make the Watch object update its status correctly when the first snapshot lands again
     client.get(url_for("ui.clear_watch_history", uuid=uuid))
@@ -163,179 +163,5 @@ def test_check_basic_change_detection_functionality(client, live_server, measure
 
     #
     # Cleanup everything
-    delete_all_watches(client)
-
-def test_non_text_mime_or_downloads(client, live_server, measure_memory_usage):
-    """
-
-    https://github.com/dgtlmoon/changedetection.io/issues/3434
-    I noticed that a watched website can be monitored fine as long as the server sends content-type: text/plain; charset=utf-8,
-    but once the server sends content-type: application/octet-stream (which is usually done to force the browser to show the Download dialog),
-    changedetection somehow ignores all line breaks and treats the document file as if everything is on one line.
-
-    WHAT THIS DOES - makes the system rely on 'magic' to determine what is it
-
-    :param client:
-    :param live_server:
-    :param measure_memory_usage:
-    :return:
-    """
-    with open("test-datastore/endpoint-content.txt", "w") as f:
-        f.write("""some random text that should be split by line
-and not parsed with html_to_text
-this way we know that it correctly parsed as plain text
-\r\n
-ok\r\n
-got it\r\n
-""")
-
-    test_url = url_for('test_endpoint', content_type="application/octet-stream", _external=True)
-
-    # Add our URL to the import page
-    uuid = client.application.config.get('DATASTORE').add_watch(url=test_url)
-    client.get(url_for("ui.form_watch_checknow"), follow_redirects=True)
-
-    wait_for_all_checks(client)
-
-    ### check the front end
-    res = client.get(
-        url_for("ui.ui_views.preview_page", uuid="first"),
-        follow_redirects=True
-    )
-    assert b"some random text that should be split by line\n" in res.data
-    ####
-
-    # Check the snapshot by API that it has linefeeds too
-    watch_uuid = next(iter(live_server.app.config['DATASTORE'].data['watching']))
-    api_key = live_server.app.config['DATASTORE'].data['settings']['application'].get('api_access_token')
-    res = client.get(
-        url_for("watchhistory", uuid=watch_uuid),
-        headers={'x-api-key': api_key},
-    )
-
-    # Fetch a snapshot by timestamp, check the right one was found
-    res = client.get(
-        url_for("watchsinglehistory", uuid=watch_uuid, timestamp=list(res.json.keys())[-1]),
-        headers={'x-api-key': api_key},
-    )
-    assert b"some random text that should be split by line\n" in res.data
-
-
-    delete_all_watches(client)
-
-
-def test_standard_text_plain(client, live_server, measure_memory_usage):
-    """
-
-    https://github.com/dgtlmoon/changedetection.io/issues/3434
-    I noticed that a watched website can be monitored fine as long as the server sends content-type: text/plain; charset=utf-8,
-    but once the server sends content-type: application/octet-stream (which is usually done to force the browser to show the Download dialog),
-    changedetection somehow ignores all line breaks and treats the document file as if everything is on one line.
-
-    The real bug here can be that it will try to process plain-text as HTML, losing <etc>
-
-    :param client:
-    :param live_server:
-    :param measure_memory_usage:
-    :return:
-    """
-    with open("test-datastore/endpoint-content.txt", "w") as f:
-        f.write("""some random text that should be split by line
-and not parsed with html_to_text
-<title>Even this title should stay because we are just plain text</title>
-this way we know that it correctly parsed as plain text
-\r\n
-ok\r\n
-got it\r\n
-""")
-
-    test_url = url_for('test_endpoint', content_type="text/plain", _external=True)
-
-    # Add our URL to the import page
-    uuid = client.application.config.get('DATASTORE').add_watch(url=test_url)
-    client.get(url_for("ui.form_watch_checknow"), follow_redirects=True)
-
-    wait_for_all_checks(client)
-
-    ### check the front end
-    res = client.get(
-        url_for("ui.ui_views.preview_page", uuid="first"),
-        follow_redirects=True
-    )
-
-    assert b"some random text that should be split by line\n" in res.data
-    ####
-
-    # Check the snapshot by API that it has linefeeds too
-    watch_uuid = next(iter(live_server.app.config['DATASTORE'].data['watching']))
-    api_key = live_server.app.config['DATASTORE'].data['settings']['application'].get('api_access_token')
-    res = client.get(
-        url_for("watchhistory", uuid=watch_uuid),
-        headers={'x-api-key': api_key},
-    )
-
-    # Fetch a snapshot by timestamp, check the right one was found
-    res = client.get(
-        url_for("watchsinglehistory", uuid=watch_uuid, timestamp=list(res.json.keys())[-1]),
-        headers={'x-api-key': api_key},
-    )
-    assert b"some random text that should be split by line\n" in res.data
-    assert b"<title>Even this title should stay because we are just plain text</title>" in res.data
-
-    delete_all_watches(client)
-
-# Server says its plaintext, we should always treat it as plaintext
-def test_plaintext_even_if_xml_content(client, live_server, measure_memory_usage):
-
-    with open("test-datastore/endpoint-content.txt", "w") as f:
-        f.write("""<?xml version="1.0" encoding="utf-8"?>
-<resources xmlns:tools="http://schemas.android.com/tools">
-    <!--Activity and fragment titles-->
-    <string name="feed_update_receiver_name">Abonnementen bijwerken</string>
-</resources>
-""")
-
-    test_url = url_for('test_endpoint', content_type="text/plain", _external=True)
-
-    # Add our URL to the import page
-    uuid = client.application.config.get('DATASTORE').add_watch(url=test_url)
-    client.get(url_for("ui.form_watch_checknow"), follow_redirects=True)
-
-    wait_for_all_checks(client)
-
-    res = client.get(
-        url_for("ui.ui_views.preview_page", uuid="first"),
-        follow_redirects=True
-    )
-
-    assert b'&lt;string name=&#34;feed_update_receiver_name&#34;' in res.data
-
-    delete_all_watches(client)
-
-# Server says its plaintext, we should always treat it as plaintext, and then if they have a filter, try to apply that
-def test_plaintext_even_if_xml_content_and_can_apply_filters(client, live_server, measure_memory_usage):
-
-
-    with open("test-datastore/endpoint-content.txt", "w") as f:
-        f.write("""<?xml version="1.0" encoding="utf-8"?>
-<resources xmlns:tools="http://schemas.android.com/tools">
-    <!--Activity and fragment titles-->
-    <string name="feed_update_receiver_name">Abonnementen bijwerken</string>
-    <foobar>ok man</foobar>
-</resources>
-""")
-
-    test_url=url_for('test_endpoint', content_type="text/plain", _external=True)
-    uuid = client.application.config.get('DATASTORE').add_watch(url=test_url, extras={"include_filters": ['//string']})
-    client.get(url_for("ui.form_watch_checknow"), follow_redirects=True)
-    wait_for_all_checks(client)
-
-    res = client.get(
-        url_for("ui.ui_views.preview_page", uuid="first"),
-        follow_redirects=True
-    )
-
-    assert b'&lt;string name=&#34;feed_update_receiver_name&#34;' in res.data
-    assert b'&lt;foobar' not in res.data
-
-    res = client.get(url_for("ui.form_delete", uuid="all"), follow_redirects=True)
+    res = client.get(url_for("ui.form_delete", uuid="all"), follow_redirects=True)
+    assert b'Deleted' in res.data

changedetectionio/tests/test_basic_socketio.py

@@ -58,7 +58,6 @@ def run_socketio_watch_update_test(client, live_server, password_mode=""):
 
     has_watch_update = False
     has_unviewed_update = False
-    got_general_stats_update = False
 
     for i in range(10):
         # Get received events
@@ -66,11 +65,15 @@ def run_socketio_watch_update_test(client, live_server, password_mode=""):
 
         if received:
             logger.info(f"Received {len(received)} events after {i+1} seconds")
+
+            # Check for watch_update events with unviewed=True
             for event in received:
                 if event['name'] == 'watch_update':
                     has_watch_update = True
-                if event['name'] == 'general_stats_update':
-                    got_general_stats_update = True
+                    if event['args'][0]['watch'].get('unviewed', False):
+                        has_unviewed_update = True
+                        logger.info("Found unviewed update event!")
+                        break
 
         if has_unviewed_update:
             break
@@ -89,7 +92,7 @@ def run_socketio_watch_update_test(client, live_server, password_mode=""):
     assert has_watch_update, "No watch_update events received"
 
     # Verify we received an unviewed event
-    assert got_general_stats_update, "Got general stats update event"
+    assert has_unviewed_update, "No watch_update event with unviewed=True received"
 
     # Alternatively, check directly if the watch in the datastore is marked as unviewed
     from changedetectionio.flask_app import app

changedetectionio/tests/test_block_while_text_present.py

@@ -2,7 +2,7 @@
 
 import time
 from flask import url_for
-from .util import live_server_setup, wait_for_all_checks, delete_all_watches
+from .util import live_server_setup, wait_for_all_checks
 from changedetectionio import html_tools
 
 def set_original_ignore_response():
@@ -70,8 +70,12 @@ def test_check_block_changedetection_text_NOT_present(client, live_server, measu
 
     # Add our URL to the import page
     test_url = url_for('test_endpoint', _external=True)
-    uuid = client.application.config.get('DATASTORE').add_watch(url=test_url)
-    client.get(url_for("ui.form_watch_checknow"), follow_redirects=True)
+    res = client.post(
+        url_for("imports.import_page"),
+        data={"urls": test_url},
+        follow_redirects=True
+    )
+    assert b"1 Imported" in res.data
 
     # Give the thread time to pick it up
     wait_for_all_checks(client)
@@ -82,8 +86,7 @@ def test_check_block_changedetection_text_NOT_present(client, live_server, measu
         url_for("ui.ui_edit.edit_page", uuid="first"),
         data={"text_should_not_be_present": ignore_text,
               "url": test_url,
-              'fetch_backend': "html_requests",
-              "time_between_check_use_default": "y"
+              'fetch_backend': "html_requests"
               },
         follow_redirects=True
     )
@@ -103,9 +106,9 @@ def test_check_block_changedetection_text_NOT_present(client, live_server, measu
     # Give the thread time to pick it up
     wait_for_all_checks(client)
 
-    # It should report nothing found (no new 'has-unread-changes' class)
+    # It should report nothing found (no new 'unviewed' class)
     res = client.get(url_for("watchlist.index"))
-    assert b'has-unread-changes' not in res.data
+    assert b'unviewed' not in res.data
     assert b'/test-endpoint' in res.data
 
     # The page changed, BUT the text is still there, just the rest of it changes, we should not see a change
@@ -116,9 +119,9 @@ def test_check_block_changedetection_text_NOT_present(client, live_server, measu
     # Give the thread time to pick it up
     wait_for_all_checks(client)
 
-    # It should report nothing found (no new 'has-unread-changes' class)
+    # It should report nothing found (no new 'unviewed' class)
     res = client.get(url_for("watchlist.index"))
-    assert b'has-unread-changes' not in res.data
+    assert b'unviewed' not in res.data
     assert b'/test-endpoint' in res.data
 
     # 2548
@@ -127,7 +130,7 @@ def test_check_block_changedetection_text_NOT_present(client, live_server, measu
     client.get(url_for("ui.form_watch_checknow"), follow_redirects=True)
     wait_for_all_checks(client)
     res = client.get(url_for("watchlist.index"))
-    assert b'has-unread-changes' not in res.data
+    assert b'unviewed' not in res.data
 
 
     # Now we set a change where the text is gone AND its different content, it should now trigger
@@ -135,9 +138,10 @@ def test_check_block_changedetection_text_NOT_present(client, live_server, measu
     client.get(url_for("ui.form_watch_checknow"), follow_redirects=True)
     wait_for_all_checks(client)
     res = client.get(url_for("watchlist.index"))
-    assert b'has-unread-changes' in res.data
+    assert b'unviewed' in res.data
 
 
 
 
-    delete_all_watches(client)
+    res = client.get(url_for("ui.form_delete", uuid="all"), follow_redirects=True)
+    assert b'Deleted' in res.data

changedetectionio/tests/test_clone.py

@@ -14,8 +14,12 @@ def test_clone_functionality(client, live_server, measure_memory_usage):
     test_url = url_for('test_endpoint', _external=True)
 
     # Add our URL to the import page
-    uuid = client.application.config.get('DATASTORE').add_watch(url=test_url)
-    client.get(url_for("ui.form_watch_checknow"), follow_redirects=True)
+    res = client.post(
+        url_for("imports.import_page"),
+        data={"urls": test_url},
+        follow_redirects=True
+    )
+    assert b"1 Imported" in res.data
     wait_for_all_checks(client)
 
     # So that we can be sure the same history doesnt carry over

changedetectionio/tests/test_conditions.py

@@ -3,7 +3,7 @@ import json
 import time
 
 from flask import url_for
-from .util import live_server_setup, wait_for_all_checks, delete_all_watches
+from .util import live_server_setup, wait_for_all_checks
 from ..model import CONDITIONS_MATCH_LOGIC_DEFAULT
 
 
@@ -47,11 +47,11 @@ def set_number_out_of_range_response(number="150"):
         f.write(test_return_data)
 
 
-# def test_setup(client, live_server, measure_memory_usage):
+# def test_setup(client, live_server):
     """Test that both text and number conditions work together with AND logic."""
    #  live_server_setup(live_server) # Setup on conftest per function
 
-def test_conditions_with_text_and_number(client, live_server, measure_memory_usage):
+def test_conditions_with_text_and_number(client, live_server):
     """Test that both text and number conditions work together with AND logic."""
     
     set_original_response("50")
@@ -60,8 +60,12 @@ def test_conditions_with_text_and_number(client, live_server, measure_memory_usa
     test_url = url_for('test_endpoint', _external=True)
 
     # Add our URL to the import page
-    uuid = client.application.config.get('DATASTORE').add_watch(url=test_url)
-    client.get(url_for("ui.form_watch_checknow"), follow_redirects=True)
+    res = client.post(
+        url_for("imports.import_page"),
+        data={"urls": test_url},
+        follow_redirects=True
+    )
+    assert b"1 Imported" in res.data
     wait_for_all_checks(client)
 
     # Configure the watch with two conditions connected with AND:
@@ -101,7 +105,6 @@ def test_conditions_with_text_and_number(client, live_server, measure_memory_usa
             "conditions-5-operator": "contains_regex",
             "conditions-5-field": "page_filtered_text",
             "conditions-5-value": "\d",
-            "time_between_check_use_default": "y",
         },
         follow_redirects=True
     )
@@ -121,7 +124,7 @@ def test_conditions_with_text_and_number(client, live_server, measure_memory_usa
     time.sleep(2)
     # 75 is > 20 and < 100 and contains "5"
     res = client.get(url_for("watchlist.index"))
-    assert b'has-unread-changes' in res.data
+    assert b'unviewed' in res.data
 
 
     # Case 2: Change with one condition violated
@@ -137,20 +140,25 @@ def test_conditions_with_text_and_number(client, live_server, measure_memory_usa
 
     # Should NOT be marked as having changes since not all conditions are met
     res = client.get(url_for("watchlist.index"))
-    assert b'has-unread-changes' not in res.data
+    assert b'unviewed' not in res.data
 
-    delete_all_watches(client)
+    res = client.get(url_for("ui.form_delete", uuid="all"), follow_redirects=True)
+    assert b'Deleted' in res.data
 
 # The 'validate' button next to each rule row
-def test_condition_validate_rule_row(client, live_server, measure_memory_usage):
+def test_condition_validate_rule_row(client, live_server):
 
     set_original_response("50")
 
     test_url = url_for('test_endpoint', _external=True)
 
     # Add our URL to the import page
-    uuid = client.application.config.get('DATASTORE').add_watch(url=test_url)
-    client.get(url_for("ui.form_watch_checknow"), follow_redirects=True)
+    res = client.post(
+        url_for("imports.import_page"),
+        data={"urls": test_url},
+        follow_redirects=True
+    )
+    assert b"1 Imported" in res.data
     wait_for_all_checks(client)
 
     uuid = next(iter(live_server.app.config['DATASTORE'].data['watching']))
@@ -221,8 +229,12 @@ def test_wordcount_conditions_plugin(client, live_server, measure_memory_usage):
 
     # Add our URL to the import page
     test_url = url_for('test_endpoint', _external=True)
-    uuid = client.application.config.get('DATASTORE').add_watch(url=test_url)
-    client.get(url_for("ui.form_watch_checknow"), follow_redirects=True)
+    res = client.post(
+        url_for("imports.import_page"),
+        data={"urls": test_url},
+        follow_redirects=True
+    )
+    assert b"1 Imported" in res.data
 
     # Give the thread time to pick it up
     wait_for_all_checks(client)
@@ -276,8 +288,7 @@ def test_lev_conditions_plugin(client, live_server, measure_memory_usage):
             "conditions_match_logic": CONDITIONS_MATCH_LOGIC_DEFAULT,  # ALL = AND logic
             "conditions-0-field": "levenshtein_ratio",
             "conditions-0-operator": "<",
-            "conditions-0-value": "0.8", # needs to be more of a diff to trigger a change
-            "time_between_check_use_default": "y"
+            "conditions-0-value": "0.8" # needs to be more of a diff to trigger a change
         },
         follow_redirects=True
     )
@@ -286,7 +297,7 @@ def test_lev_conditions_plugin(client, live_server, measure_memory_usage):
 
     wait_for_all_checks(client)
     res = client.get(url_for("watchlist.index"))
-    assert b'has-unread-changes' not in res.data
+    assert b'unviewed' not in res.data
 
     # Check the content saved initially, even tho a condition was set - this is the first snapshot so shouldnt be affected by conditions
     res = client.get(
@@ -313,7 +324,7 @@ def test_lev_conditions_plugin(client, live_server, measure_memory_usage):
     wait_for_all_checks(client)
 
     res = client.get(url_for("watchlist.index"))
-    assert b'has-unread-changes' not in res.data #because this will be like 0.90 not 0.8 threshold
+    assert b'unviewed' not in res.data #because this will be like 0.90 not 0.8 threshold
 
     ############### Now change it a MORE THAN 50%
     test_return_data = """<html>
@@ -332,7 +343,7 @@ def test_lev_conditions_plugin(client, live_server, measure_memory_usage):
     assert b'Queued 1 watch for rechecking.' in res.data
     wait_for_all_checks(client)
     res = client.get(url_for("watchlist.index"))
-    assert b'has-unread-changes' in res.data
+    assert b'unviewed' in res.data
     # cleanup for the next
     client.get(
         url_for("ui.form_delete", uuid="all"),

changedetectionio/tests/test_css_selector.py

@@ -81,8 +81,12 @@ def test_check_markup_include_filters_restriction(client, live_server, measure_m
 
     # Add our URL to the import page
     test_url = url_for('test_endpoint', _external=True)
-    uuid = client.application.config.get('DATASTORE').add_watch(url=test_url)
-    client.get(url_for("ui.form_watch_checknow"), follow_redirects=True)
+    res = client.post(
+        url_for("imports.import_page"),
+        data={"urls": test_url},
+        follow_redirects=True
+    )
+    assert b"1 Imported" in res.data
 
     # Give the thread time to pick it up
     time.sleep(sleep_time_for_fetch_thread)
@@ -91,7 +95,7 @@ def test_check_markup_include_filters_restriction(client, live_server, measure_m
     # Add our URL to the import page
     res = client.post(
         url_for("ui.ui_edit.edit_page", uuid="first"),
-        data={"include_filters": include_filters, "url": test_url, "tags": "", "headers": "", 'fetch_backend': "html_requests", "time_between_check_use_default": "y"},
+        data={"include_filters": include_filters, "url": test_url, "tags": "", "headers": "", 'fetch_backend': "html_requests"},
         follow_redirects=True
     )
     assert b"Updated watch." in res.data
@@ -112,10 +116,10 @@ def test_check_markup_include_filters_restriction(client, live_server, measure_m
     # Give the thread time to pick it up
     time.sleep(sleep_time_for_fetch_thread)
 
-    # It should have 'has-unread-changes' still
+    # It should have 'unviewed' still
     # Because it should be looking at only that 'sametext' id
     res = client.get(url_for("watchlist.index"))
-    assert b'has-unread-changes' in res.data
+    assert b'unviewed' in res.data
 
 
 # Tests the whole stack works with the CSS Filter
@@ -134,8 +138,12 @@ def test_check_multiple_filters(client, live_server, measure_memory_usage):
 
     # Add our URL to the import page
     test_url = url_for('test_endpoint', _external=True)
-    uuid = client.application.config.get('DATASTORE').add_watch(url=test_url)
-    client.get(url_for("ui.form_watch_checknow"), follow_redirects=True)
+    res = client.post(
+        url_for("imports.import_page"),
+        data={"urls": test_url},
+        follow_redirects=True
+    )
+    assert b"1 Imported" in res.data
     wait_for_all_checks(client)
 
     # Goto the edit page, add our ignore text
@@ -146,8 +154,7 @@ def test_check_multiple_filters(client, live_server, measure_memory_usage):
               "url": test_url,
               "tags": "",
               "headers": "",
-              'fetch_backend': "html_requests",
-              "time_between_check_use_default": "y"},
+              'fetch_backend': "html_requests"},
         follow_redirects=True
     )
     assert b"Updated watch." in res.data
@@ -185,8 +192,12 @@ def test_filter_is_empty_help_suggestion(client, live_server, measure_memory_usa
 
     # Add our URL to the import page
     test_url = url_for('test_endpoint', _external=True)
-    uuid = client.application.config.get('DATASTORE').add_watch(url=test_url)
-    client.get(url_for("ui.form_watch_checknow"), follow_redirects=True)
+    res = client.post(
+        url_for("imports.import_page"),
+        data={"urls": test_url},
+        follow_redirects=True
+    )
+    assert b"1 Imported" in res.data
     wait_for_all_checks(client)
 
     # Goto the edit page, add our ignore text
@@ -197,8 +208,7 @@ def test_filter_is_empty_help_suggestion(client, live_server, measure_memory_usa
               "url": test_url,
               "tags": "",
               "headers": "",
-              'fetch_backend': "html_requests",
-              "time_between_check_use_default": "y"},
+              'fetch_backend': "html_requests"},
         follow_redirects=True
     )
     assert b"Updated watch." in res.data

changedetectionio/tests/test_element_removal.py

@@ -5,7 +5,7 @@ import time
 from flask import url_for
 
 from ..html_tools import *
-from .util import live_server_setup, wait_for_all_checks, delete_all_watches
+from .util import live_server_setup, wait_for_all_checks
 
 
 
@@ -171,7 +171,6 @@ def test_element_removal_full(client, live_server, measure_memory_usage):
             "tags": "",
             "headers": "",
             "fetch_backend": "html_requests",
-            "time_between_check_use_default": "y",
         },
         follow_redirects=True,
     )
@@ -190,7 +189,7 @@ def test_element_removal_full(client, live_server, measure_memory_usage):
 
     wait_for_all_checks(client)
 
-    # so that we set the state to 'has-unread-changes' after all the edits
+    # so that we set the state to 'unviewed' after all the edits
     client.get(url_for("ui.ui_views.diff_history_page", uuid="first"))
 
     #  Make a change to header/footer/nav
@@ -209,32 +208,47 @@ def test_element_removal_full(client, live_server, measure_memory_usage):
 
 # Re #2752
 def test_element_removal_nth_offset_no_shift(client, live_server, measure_memory_usage):
+    
 
     set_response_with_multiple_index()
-    subtractive_selectors_data = [
-### css style ###
-"""body > table > tr:nth-child(1) > th:nth-child(2)
+    subtractive_selectors_data = ["""
+body > table > tr:nth-child(1) > th:nth-child(2)
 body > table >  tr:nth-child(2) > td:nth-child(2)
 body > table > tr:nth-child(3) > td:nth-child(2)
 body > table > tr:nth-child(1) > th:nth-child(3)
 body > table >  tr:nth-child(2) > td:nth-child(3)
 body > table > tr:nth-child(3) > td:nth-child(3)""",
-### second type, xpath ###
 """//body/table/tr[1]/th[2]
 //body/table/tr[2]/td[2]
 //body/table/tr[3]/td[2]
 //body/table/tr[1]/th[3]
 //body/table/tr[2]/td[3]
 //body/table/tr[3]/td[3]"""]
-    
-    test_url = url_for("test_endpoint", _external=True)
 
     for selector_list in subtractive_selectors_data:
 
-        delete_all_watches(client)
+        res = client.get(url_for("ui.form_delete", uuid="all"), follow_redirects=True)
+        assert b'Deleted' in res.data
 
-        uuid = client.application.config.get('DATASTORE').add_watch(url=test_url, extras={"subtractive_selectors": selector_list.splitlines()})
-        client.get(url_for("ui.form_watch_checknow"), follow_redirects=True)
+        # Add our URL to the import page
+        test_url = url_for("test_endpoint", _external=True)
+        res = client.post(
+            url_for("imports.import_page"), data={"urls": test_url}, follow_redirects=True
+        )
+        assert b"1 Imported" in res.data
+        wait_for_all_checks(client)
+
+        res = client.post(
+            url_for("ui.ui_edit.edit_page", uuid="first"),
+            data={
+                "subtractive_selectors": selector_list,
+                "url": test_url,
+                "tags": "",
+                "fetch_backend": "html_requests",
+            },
+            follow_redirects=True,
+        )
+        assert b"Updated watch." in res.data
         wait_for_all_checks(client)
 
         res = client.get(
@@ -242,7 +256,6 @@ body > table > tr:nth-child(3) > td:nth-child(3)""",
             follow_redirects=True
         )
 
-        # the filters above should have removed this but they never say to remove the "emil" column
         assert b"Tobias" not in res.data
         assert b"Linus" not in res.data
         assert b"Person 2" not in res.data

changedetectionio/tests/test_encoding.py

@@ -28,8 +28,11 @@ def test_check_encoding_detection(client, live_server, measure_memory_usage):
 
     # Add our URL to the import page
     test_url = url_for('test_endpoint', content_type="text/html", _external=True)
-    uuid = client.application.config.get('DATASTORE').add_watch(url=test_url)
-    client.get(url_for("ui.form_watch_checknow"), follow_redirects=True)
+    client.post(
+        url_for("imports.import_page"),
+        data={"urls": test_url},
+        follow_redirects=True
+    )
 
     # Give the thread time to pick it up
     wait_for_all_checks(client)
@@ -56,8 +59,11 @@ def test_check_encoding_detection_missing_content_type_header(client, live_serve
 
     # Add our URL to the import page
     test_url = url_for('test_endpoint', _external=True)
-    uuid = client.application.config.get('DATASTORE').add_watch(url=test_url)
-    client.get(url_for("ui.form_watch_checknow"), follow_redirects=True)
+    client.post(
+        url_for("imports.import_page"),
+        data={"urls": test_url},
+        follow_redirects=True
+    )
 
     wait_for_all_checks(client)
 

changedetectionio/tests/test_errorhandling.py

@@ -3,7 +3,7 @@
 import time
 
 from flask import url_for
-from .util import live_server_setup, wait_for_all_checks, delete_all_watches
+from .util import live_server_setup, wait_for_all_checks
 
 
 
@@ -19,15 +19,19 @@ def _runner_test_http_errors(client, live_server, http_code, expected_text):
                        status_code=http_code,
                        _external=True)
 
-    uuid = client.application.config.get('DATASTORE').add_watch(url=test_url)
-    client.get(url_for("ui.form_watch_checknow"), follow_redirects=True)
+    res = client.post(
+        url_for("imports.import_page"),
+        data={"urls": test_url},
+        follow_redirects=True
+    )
+    assert b"1 Imported" in res.data
 
     # Give the thread time to pick it up
     wait_for_all_checks(client)
 
     res = client.get(url_for("watchlist.index"))
     # no change
-    assert b'has-unread-changes' not in res.data
+    assert b'unviewed' not in res.data
     assert bytes(expected_text.encode('utf-8')) in res.data
 
 
@@ -43,7 +47,8 @@ def _runner_test_http_errors(client, live_server, http_code, expected_text):
     #assert b'Error Screenshot' in res.data
 
 
-    delete_all_watches(client)
+    res = client.get(url_for("ui.form_delete", uuid="all"), follow_redirects=True)
+    assert b'Deleted' in res.data
 
 
 def test_http_error_handler(client, live_server, measure_memory_usage):
@@ -51,7 +56,8 @@ def test_http_error_handler(client, live_server, measure_memory_usage):
     _runner_test_http_errors(client, live_server, 404, 'Page not found')
     _runner_test_http_errors(client, live_server, 500, '(Internal server error) received')
     _runner_test_http_errors(client, live_server, 400, 'Error - Request returned a HTTP error code 400')
-    delete_all_watches(client)
+    res = client.get(url_for("ui.form_delete", uuid="all"), follow_redirects=True)
+    assert b'Deleted' in res.data
 
 # Just to be sure error text is properly handled
 def test_DNS_errors(client, live_server, measure_memory_usage):
@@ -81,7 +87,8 @@ def test_DNS_errors(client, live_server, measure_memory_usage):
     assert found_name_resolution_error
     # Should always record that we tried
     assert bytes("just now".encode('utf-8')) in res.data
-    delete_all_watches(client)
+    res = client.get(url_for("ui.form_delete", uuid="all"), follow_redirects=True)
+    assert b'Deleted' in res.data
 
 # Re 1513
 def test_low_level_errors_clear_correctly(client, live_server, measure_memory_usage):
@@ -120,8 +127,7 @@ def test_low_level_errors_clear_correctly(client, live_server, measure_memory_us
         url_for("ui.ui_edit.edit_page", uuid="first"),
         data={
             "url": test_url,
-            "fetch_backend": "html_requests",
-            "time_between_check_use_default": "y"},
+            "fetch_backend": "html_requests"},
         follow_redirects=True
     )
 
@@ -138,4 +144,5 @@ def test_low_level_errors_clear_correctly(client, live_server, measure_memory_us
     )
     assert not found_name_resolution_error
 
-    delete_all_watches(client)
+    res = client.get(url_for("ui.form_delete", uuid="all"), follow_redirects=True)
+    assert b'Deleted' in res.data

changedetectionio/tests/test_extract_regex.py

@@ -2,7 +2,7 @@
 
 import time
 from flask import url_for
-from .util import live_server_setup, wait_for_all_checks, delete_all_watches
+from .util import live_server_setup, wait_for_all_checks
 
 from ..html_tools import *
 
@@ -76,8 +76,12 @@ def test_check_filter_multiline(client, live_server, measure_memory_usage):
 
     # Add our URL to the import page
     test_url = url_for('test_endpoint', _external=True)
-    uuid = client.application.config.get('DATASTORE').add_watch(url=test_url)
-    client.get(url_for("ui.form_watch_checknow"), follow_redirects=True)
+    res = client.post(
+        url_for("imports.import_page"),
+        data={"urls": test_url},
+        follow_redirects=True
+    )
+    assert b"1 Imported" in res.data
 
     wait_for_all_checks(client)
 
@@ -91,8 +95,7 @@ def test_check_filter_multiline(client, live_server, measure_memory_usage):
               "url": test_url,
               "tags": "",
               "headers": "",
-              'fetch_backend': "html_requests",
-              "time_between_check_use_default": "y"
+              'fetch_backend': "html_requests"
               },
         follow_redirects=True
     )
@@ -127,8 +130,12 @@ def test_check_filter_and_regex_extract(client, live_server, measure_memory_usag
 
     # Add our URL to the import page
     test_url = url_for('test_endpoint', _external=True)
-    uuid = client.application.config.get('DATASTORE').add_watch(url=test_url)
-    client.get(url_for("ui.form_watch_checknow"), follow_redirects=True)
+    res = client.post(
+        url_for("imports.import_page"),
+        data={"urls": test_url},
+        follow_redirects=True
+    )
+    assert b"1 Imported" in res.data
 
     # Give the thread time to pick it up
     wait_for_all_checks(client)
@@ -142,8 +149,7 @@ def test_check_filter_and_regex_extract(client, live_server, measure_memory_usag
               "url": test_url,
               "tags": "",
               "headers": "",
-              'fetch_backend': "html_requests",
-              "time_between_check_use_default": "y"
+              'fetch_backend': "html_requests"
               },
         follow_redirects=True
     )
@@ -166,10 +172,10 @@ def test_check_filter_and_regex_extract(client, live_server, measure_memory_usag
     # Give the thread time to pick it up
     wait_for_all_checks(client)
 
-    # It should have 'has-unread-changes' still
+    # It should have 'unviewed' still
     # Because it should be looking at only that 'sametext' id
     res = client.get(url_for("watchlist.index"))
-    assert b'has-unread-changes' in res.data
+    assert b'unviewed' in res.data
 
     # Check HTML conversion detected and workd
     res = client.get(
@@ -204,19 +210,23 @@ def test_regex_error_handling(client, live_server, measure_memory_usage):
 
     # Add our URL to the import page
     test_url = url_for('test_endpoint', _external=True)
-    uuid = client.application.config.get('DATASTORE').add_watch(url=test_url)
-    client.get(url_for("ui.form_watch_checknow"), follow_redirects=True)
+    res = client.post(
+        url_for("imports.import_page"),
+        data={"urls": test_url},
+        follow_redirects=True
+    )
+    assert b"1 Imported" in res.data
 
     ### test regex error handling
     res = client.post(
         url_for("ui.ui_edit.edit_page", uuid="first"),
         data={"extract_text": '/something bad\d{3/XYZ',
               "url": test_url,
-              "fetch_backend": "html_requests",
-              "time_between_check_use_default": "y"},
+              "fetch_backend": "html_requests"},
         follow_redirects=True
     )
 
     assert b'is not a valid regular expression.' in res.data
 
-    delete_all_watches(client)
+    res = client.get(url_for("ui.form_delete", uuid="all"), follow_redirects=True)
+    assert b'Deleted' in res.data

changedetectionio/tests/test_filter_exist_changes.py

@@ -94,8 +94,7 @@ def test_filter_doesnt_exist_then_exists_should_get_notification(client, live_se
         "title": "my title",
         "headers": "",
         "include_filters": '.ticket-available',
-        "fetch_backend": "html_requests",
-        "time_between_check_use_default": "y"})
+        "fetch_backend": "html_requests"})
 
     res = client.post(
         url_for("ui.ui_edit.edit_page", uuid="first"),

changedetectionio/tests/test_filter_failure_notification.py

@@ -42,8 +42,13 @@ def run_filter_test(client, live_server, content_filter):
     if os.path.isfile("test-datastore/notification.txt"):
         os.unlink("test-datastore/notification.txt")
 
-    uuid = client.application.config.get('DATASTORE').add_watch(url=test_url)
-    client.get(url_for("ui.form_watch_checknow"), follow_redirects=True)
+    res = client.post(
+        url_for("imports.import_page"),
+        data={"urls": test_url},
+        follow_redirects=True
+    )
+
+    assert b"1 Imported" in res.data
     wait_for_all_checks(client)
 
     uuid = next(iter(live_server.app.config['DATASTORE'].data['watching']))
@@ -67,7 +72,6 @@ def run_filter_test(client, live_server, content_filter):
                   "notification_format": "Text",
                   "fetch_backend": "html_requests",
                   "filter_failure_notification_send": 'y',
-                  "time_between_check_use_default": "y",
                   "headers": "",
                   "tags": "my tag",
                   "title": "my title 123",

changedetectionio/tests/test_group.py

@@ -2,7 +2,7 @@
 
 import time
 from flask import url_for
-from .util import live_server_setup, wait_for_all_checks, extract_rss_token_from_UI, get_UUID_for_tag_name, extract_UUID_from_client, delete_all_watches
+from .util import live_server_setup, wait_for_all_checks, extract_rss_token_from_UI, get_UUID_for_tag_name, extract_UUID_from_client
 import os
 
 
@@ -127,7 +127,8 @@ def test_setup_group_tag(client, live_server, measure_memory_usage):
     assert b"should-be-excluded" not in res.data
     assert res.status_code == 200
     assert b"first-imported=1" in res.data
-    delete_all_watches(client)
+    res = client.get(url_for("ui.form_delete", uuid="all"), follow_redirects=True)
+    assert b'Deleted' in res.data
 
 def test_tag_import_singular(client, live_server, measure_memory_usage):
     
@@ -146,7 +147,8 @@ def test_tag_import_singular(client, live_server, measure_memory_usage):
     )
     # Should be only 1 tag because they both had the same
     assert res.data.count(b'test-tag') == 1
-    delete_all_watches(client)
+    res = client.get(url_for("ui.form_delete", uuid="all"), follow_redirects=True)
+    assert b'Deleted' in res.data
 
 def test_tag_add_in_ui(client, live_server, measure_memory_usage):
     
@@ -162,7 +164,8 @@ def test_tag_add_in_ui(client, live_server, measure_memory_usage):
     res = client.get(url_for("tags.delete_all"), follow_redirects=True)
     assert b'All tags deleted' in res.data
 
-    delete_all_watches(client)
+    res = client.get(url_for("ui.form_delete", uuid="all"), follow_redirects=True)
+    assert b'Deleted' in res.data
 
 def test_group_tag_notification(client, live_server, measure_memory_usage):
     
@@ -229,7 +232,8 @@ def test_group_tag_notification(client, live_server, measure_memory_usage):
 
     #@todo Test that multiple notifications fired
     #@todo Test that each of multiple notifications with different settings
-    delete_all_watches(client)
+    res = client.get(url_for("ui.form_delete", uuid="all"), follow_redirects=True)
+    assert b'Deleted' in res.data
 
 def test_limit_tag_ui(client, live_server, measure_memory_usage):
 
@@ -260,12 +264,15 @@ def test_limit_tag_ui(client, live_server, measure_memory_usage):
     client.get(url_for('ui.mark_all_viewed', tag=tag_uuid), follow_redirects=True)
     wait_for_all_checks(client)
 
+    with open('/tmp/fuck.html', 'wb') as f:
+        f.write(res.data)
     # Should be only 1 unviewed
     res = client.get(url_for("watchlist.index"))
     assert res.data.count(b' unviewed ') == 1
 
 
-    delete_all_watches(client)
+    res = client.get(url_for("ui.form_delete", uuid="all"), follow_redirects=True)
+    assert b'Deleted' in res.data
     res = client.get(url_for("tags.delete_all"), follow_redirects=True)
     assert b'All tags deleted' in res.data
 
@@ -292,7 +299,8 @@ def test_clone_tag_on_import(client, live_server, measure_memory_usage):
     # 2 times plus the top link to tag
     assert res.data.count(b'test-tag') == 3
     assert res.data.count(b'another-tag') == 3
-    delete_all_watches(client)
+    res = client.get(url_for("ui.form_delete", uuid="all"), follow_redirects=True)
+    assert b'Deleted' in res.data
 
 def test_clone_tag_on_quickwatchform_add(client, live_server, measure_memory_usage):
     
@@ -319,7 +327,8 @@ def test_clone_tag_on_quickwatchform_add(client, live_server, measure_memory_usa
     # 2 times plus the top link to tag
     assert res.data.count(b'test-tag') == 3
     assert res.data.count(b'another-tag') == 3
-    delete_all_watches(client)
+    res = client.get(url_for("ui.form_delete", uuid="all"), follow_redirects=True)
+    assert b'Deleted' in res.data
 
     res = client.get(url_for("tags.delete_all"), follow_redirects=True)
     assert b'All tags deleted' in res.data
@@ -382,8 +391,12 @@ def test_order_of_filters_tag_filter_and_watch_filter(client, live_server, measu
         f.write(d)
 
     test_url = url_for('test_endpoint', _external=True)
-    uuid = client.application.config.get('DATASTORE').add_watch(url=test_url)
-    client.get(url_for("ui.form_watch_checknow"), follow_redirects=True)
+    res = client.post(
+        url_for("imports.import_page"),
+        data={"urls": test_url},
+        follow_redirects=True
+    )
+    assert b"1 Imported" in res.data
     wait_for_all_checks(client)
 
     filters = [
@@ -411,8 +424,7 @@ def test_order_of_filters_tag_filter_and_watch_filter(client, live_server, measu
             "url": test_url,
             "tags": "test-tag-keep-order",
             "headers": "",
-            'fetch_backend': "html_requests",
-            "time_between_check_use_default": "y"},
+            'fetch_backend': "html_requests"},
         follow_redirects=True
     )
     assert b"Updated watch." in res.data
@@ -469,4 +481,5 @@ the {test} appeared before. {test in res.data[:n]=}
         """
         n += t_index + len(test)
 
-    delete_all_watches(client)
+    res = client.get(url_for("ui.form_delete", uuid="all"), follow_redirects=True)
+    assert b'Deleted' in res.data

changedetectionio/tests/test_history_consistency.py

@@ -3,8 +3,9 @@
 import time
 import os
 import json
+import logging
 from flask import url_for
-from .util import wait_for_all_checks, delete_all_watches
+from .util import live_server_setup, wait_for_all_checks
 from urllib.parse import urlparse, parse_qs
 
 def test_consistent_history(client, live_server, measure_memory_usage):
@@ -80,15 +81,19 @@ def test_consistent_history(client, live_server, measure_memory_usage):
         assert '"default"' not in f.read(), "'default' probably shouldnt be here, it came from when the 'default' Watch vars were accidently being saved"
 
 
-def test_check_text_history_view(client, live_server, measure_memory_usage):
+def test_check_text_history_view(client, live_server):
 
     with open("test-datastore/endpoint-content.txt", "w") as f:
         f.write("<html>test-one</html>")
 
     # Add our URL to the import page
     test_url = url_for('test_endpoint', _external=True)
-    uuid = client.application.config.get('DATASTORE').add_watch(url=test_url)
-    client.get(url_for("ui.form_watch_checknow"), follow_redirects=True)
+    res = client.post(
+        url_for("imports.import_page"),
+        data={"urls": test_url},
+        follow_redirects=True
+    )
+    assert b"1 Imported" in res.data
 
     # Give the thread time to pick it up
     wait_for_all_checks(client)
@@ -117,4 +122,5 @@ def test_check_text_history_view(client, live_server, measure_memory_usage):
     assert b'test-two' in res.data
     assert b'test-one' not in res.data
 
-    delete_all_watches(client)
+    res = client.get(url_for("ui.form_delete", uuid="all"), follow_redirects=True)
+    assert b'Deleted' in res.data

changedetectionio/tests/test_ignore.py

@@ -27,8 +27,12 @@ def test_ignore(client, live_server, measure_memory_usage):
    #  live_server_setup(live_server) # Setup on conftest per function
     set_original_ignore_response()
     test_url = url_for('test_endpoint', _external=True)
-    uuid = client.application.config.get('DATASTORE').add_watch(url=test_url)
-    client.get(url_for("ui.form_watch_checknow"), follow_redirects=True)
+    res = client.post(
+        url_for("imports.import_page"),
+        data={"urls": test_url},
+        follow_redirects=True
+    )
+    assert b"1 Imported" in res.data
 
     # Give the thread time to pick it up
     wait_for_all_checks(client)
@@ -54,35 +58,3 @@ def test_ignore(client, live_server, measure_memory_usage):
     # Should be in base.html
     assert b'csrftoken' in res.data
 
-
-def test_strip_ignore_lines(client, live_server, measure_memory_usage):
-   #  live_server_setup(live_server) # Setup on conftest per function
-    set_original_ignore_response()
-
-
-    # Goto the settings page, add our ignore text
-    res = client.post(
-        url_for("settings.settings_page"),
-        data={
-            "requests-time_between_check-minutes": 180,
-            "application-ignore_whitespace": "y",
-            "application-strip_ignored_lines": "y",
-            "application-global_ignore_text": "Which is across multiple",
-            'application-fetch_backend': "html_requests"
-        },
-        follow_redirects=True
-    )
-    assert b"Settings updated." in res.data
-
-    test_url = url_for('test_endpoint', _external=True)
-    uuid = client.application.config.get('DATASTORE').add_watch(url=test_url)
-    client.get(url_for("ui.form_watch_checknow"), follow_redirects=True)
-
-    # Give the thread time to pick it up
-    wait_for_all_checks(client)
-    uuid = next(iter(live_server.app.config['DATASTORE'].data['watching']))
-
-    # It should not be in the preview anymore
-    res = client.get(url_for("ui.ui_views.preview_page", uuid=uuid))
-    assert b'<div class="ignored">' not in res.data
-    assert b'Which is across multiple' not in res.data

changedetectionio/tests/test_ignore_text.py

@@ -2,7 +2,7 @@
 
 import time
 from flask import url_for
-from .util import live_server_setup, wait_for_all_checks, delete_all_watches
+from .util import live_server_setup, wait_for_all_checks
 from changedetectionio import html_tools
 
 
@@ -97,8 +97,12 @@ def test_check_ignore_text_functionality(client, live_server, measure_memory_usa
 
     # Add our URL to the import page
     test_url = url_for('test_endpoint', _external=True)
-    uuid = client.application.config.get('DATASTORE').add_watch(url=test_url)
-    client.get(url_for("ui.form_watch_checknow"), follow_redirects=True)
+    res = client.post(
+        url_for("imports.import_page"),
+        data={"urls": test_url},
+        follow_redirects=True
+    )
+    assert b"1 Imported" in res.data
 
     # Give the thread time to pick it up
     wait_for_all_checks(client)
@@ -107,7 +111,7 @@ def test_check_ignore_text_functionality(client, live_server, measure_memory_usa
     # Add our URL to the import page
     res = client.post(
         url_for("ui.ui_edit.edit_page", uuid="first"),
-        data={"ignore_text": ignore_text, "url": test_url, 'fetch_backend': "html_requests", "time_between_check_use_default": "y"},
+        data={"ignore_text": ignore_text, "url": test_url, 'fetch_backend': "html_requests"},
         follow_redirects=True
     )
     assert b"Updated watch." in res.data
@@ -124,9 +128,9 @@ def test_check_ignore_text_functionality(client, live_server, measure_memory_usa
     # Give the thread time to pick it up
     wait_for_all_checks(client)
 
-    # It should report nothing found (no new 'has-unread-changes' class)
+    # It should report nothing found (no new 'unviewed' class)
     res = client.get(url_for("watchlist.index"))
-    assert b'has-unread-changes' not in res.data
+    assert b'unviewed' not in res.data
     assert b'/test-endpoint' in res.data
 
     #  Make a change
@@ -137,9 +141,9 @@ def test_check_ignore_text_functionality(client, live_server, measure_memory_usa
     # Give the thread time to pick it up
     wait_for_all_checks(client)
 
-    # It should report nothing found (no new 'has-unread-changes' class)
+    # It should report nothing found (no new 'unviewed' class)
     res = client.get(url_for("watchlist.index"))
-    assert b'has-unread-changes' not in res.data
+    assert b'unviewed' not in res.data
     assert b'/test-endpoint' in res.data
 
 
@@ -150,7 +154,7 @@ def test_check_ignore_text_functionality(client, live_server, measure_memory_usa
     wait_for_all_checks(client)
 
     res = client.get(url_for("watchlist.index"))
-    assert b'has-unread-changes' in res.data
+    assert b'unviewed' in res.data
 
     res = client.get(url_for("ui.ui_views.preview_page", uuid="first"))
 
@@ -159,7 +163,8 @@ def test_check_ignore_text_functionality(client, live_server, measure_memory_usa
     # it is only ignored, it is not removed (it will be highlighted too)
     assert b'new ignore stuff' in res.data
 
-    delete_all_watches(client)
+    res = client.get(url_for("ui.form_delete", uuid="all"), follow_redirects=True)
+    assert b'Deleted' in res.data
 
 # When adding some ignore text, it should not trigger a change, even if something else on that line changes
 def _run_test_global_ignore(client, as_source=False, extra_ignore=""):
@@ -187,8 +192,12 @@ def _run_test_global_ignore(client, as_source=False, extra_ignore=""):
         # Switch to source mode so we can test that too!
         test_url = "source:"+test_url
 
-    uuid = client.application.config.get('DATASTORE').add_watch(url=test_url)
-    client.get(url_for("ui.form_watch_checknow"), follow_redirects=True)
+    res = client.post(
+        url_for("imports.import_page"),
+        data={"urls": test_url},
+        follow_redirects=True
+    )
+    assert b"1 Imported" in res.data
 
     # Give the thread time to pick it up
     wait_for_all_checks(client)
@@ -196,7 +205,7 @@ def _run_test_global_ignore(client, as_source=False, extra_ignore=""):
     #Adding some ignore text should not trigger a change
     res = client.post(
         url_for("ui.ui_edit.edit_page", uuid="first"),
-        data={"ignore_text": "something irrelevent but just to check", "url": test_url, 'fetch_backend': "html_requests", "time_between_check_use_default": "y"},
+        data={"ignore_text": "something irrelevent but just to check", "url": test_url, 'fetch_backend': "html_requests"},
         follow_redirects=True
     )
     assert b"Updated watch." in res.data
@@ -213,9 +222,9 @@ def _run_test_global_ignore(client, as_source=False, extra_ignore=""):
     # Trigger a check
     client.get(url_for("ui.form_watch_checknow"), follow_redirects=True)
     wait_for_all_checks(client)
-    # It should report nothing found (no new 'has-unread-changes' class), adding random ignore text should not cause a change
+    # It should report nothing found (no new 'unviewed' class), adding random ignore text should not cause a change
     res = client.get(url_for("watchlist.index"))
-    assert b'has-unread-changes' not in res.data
+    assert b'unviewed' not in res.data
     assert b'/test-endpoint' in res.data
 #####
 
@@ -229,10 +238,10 @@ def _run_test_global_ignore(client, as_source=False, extra_ignore=""):
     # Give the thread time to pick it up
     wait_for_all_checks(client)
 
-    # It should report nothing found (no new 'has-unread-changes' class)
+    # It should report nothing found (no new 'unviewed' class)
     res = client.get(url_for("watchlist.index"))
 
-    assert b'has-unread-changes' not in res.data
+    assert b'unviewed' not in res.data
     assert b'/test-endpoint' in res.data
 
     # Just to be sure.. set a regular modified change that will trigger it
@@ -240,14 +249,15 @@ def _run_test_global_ignore(client, as_source=False, extra_ignore=""):
     client.get(url_for("ui.form_watch_checknow"), follow_redirects=True)
     wait_for_all_checks(client)
     res = client.get(url_for("watchlist.index"))
-    assert b'has-unread-changes' in res.data
+    assert b'unviewed' in res.data
 
-    delete_all_watches(client)
+    res = client.get(url_for("ui.form_delete", uuid="all"), follow_redirects=True)
+    assert b'Deleted' in res.data
 
-def test_check_global_ignore_text_functionality(client, live_server, measure_memory_usage):
+def test_check_global_ignore_text_functionality(client, live_server):
     
     _run_test_global_ignore(client, as_source=False)
 
-def test_check_global_ignore_text_functionality_as_source(client, live_server, measure_memory_usage):
+def test_check_global_ignore_text_functionality_as_source(client, live_server):
     
     _run_test_global_ignore(client, as_source=True, extra_ignore='/\?v=\d/')

changedetectionio/tests/test_ignorehyperlinks.py

@@ -3,7 +3,9 @@
 
 import time
 from flask import url_for
-from .util import live_server_setup, wait_for_all_checks, delete_all_watches
+from .util import live_server_setup, wait_for_all_checks
+
+
 
 
 def set_original_ignore_response():
@@ -109,11 +111,13 @@ def test_render_anchor_tag_content_true(client, live_server, measure_memory_usag
     assert '(/modified_link)' in res.data.decode()
 
     # since the link has changed, and we chose to render anchor tag content,
-    # we should detect a change (new 'has-unread-changes' class)
+    # we should detect a change (new 'unviewed' class)
     res = client.get(url_for("watchlist.index"))
     assert b"unviewed" in res.data
     assert b"/test-endpoint" in res.data
 
     # Cleanup everything
-    delete_all_watches(client)
+    res = client.get(url_for("ui.form_delete", uuid="all"),
+                     follow_redirects=True)
+    assert b'Deleted' in res.data
 

changedetectionio/tests/test_ignorestatuscode.py

@@ -60,8 +60,12 @@ def test_normal_page_check_works_with_ignore_status_code(client, live_server, me
 
     # Add our URL to the import page
     test_url = url_for('test_endpoint', _external=True)
-    uuid = client.application.config.get('DATASTORE').add_watch(url=test_url)
-    client.get(url_for("ui.form_watch_checknow"), follow_redirects=True)
+    res = client.post(
+        url_for("imports.import_page"),
+        data={"urls": test_url},
+        follow_redirects=True
+    )
+    assert b"1 Imported" in res.data
 
     wait_for_all_checks(client)
 
@@ -73,9 +77,9 @@ def test_normal_page_check_works_with_ignore_status_code(client, live_server, me
     # Give the thread time to pick it up
     wait_for_all_checks(client)
 
-    # It should report nothing found (no new 'has-unread-changes' class)
+    # It should report nothing found (no new 'unviewed' class)
     res = client.get(url_for("watchlist.index"))
-    assert b'has-unread-changes' in res.data
+    assert b'unviewed' in res.data
     assert b'/test-endpoint' in res.data
 
 
@@ -90,8 +94,12 @@ def test_403_page_check_works_with_ignore_status_code(client, live_server, measu
 
     # Add our URL to the import page
     test_url = url_for('test_endpoint', status_code=403, _external=True)
-    uuid = client.application.config.get('DATASTORE').add_watch(url=test_url)
-    client.get(url_for("ui.form_watch_checknow"), follow_redirects=True)
+    res = client.post(
+        url_for("imports.import_page"),
+        data={"urls": test_url},
+        follow_redirects=True
+    )
+    assert b"1 Imported" in res.data
 
     # Give the thread time to pick it up
     time.sleep(sleep_time_for_fetch_thread)
@@ -100,7 +108,7 @@ def test_403_page_check_works_with_ignore_status_code(client, live_server, measu
     # Add our URL to the import page
     res = client.post(
         url_for("ui.ui_edit.edit_page", uuid="first"),
-        data={"ignore_status_codes": "y", "url": test_url, "tags": "", "headers": "", 'fetch_backend': "html_requests", "time_between_check_use_default": "y"},
+        data={"ignore_status_codes": "y", "url": test_url, "tags": "", "headers": "", 'fetch_backend': "html_requests"},
         follow_redirects=True
     )
     assert b"Updated watch." in res.data
@@ -116,8 +124,8 @@ def test_403_page_check_works_with_ignore_status_code(client, live_server, measu
     # Give the thread time to pick it up
     wait_for_all_checks(client)
 
-    # It should have 'has-unread-changes' still
+    # It should have 'unviewed' still
     # Because it should be looking at only that 'sametext' id
     res = client.get(url_for("watchlist.index"))
-    assert b'has-unread-changes' in res.data
+    assert b'unviewed' in res.data
 

changedetectionio/tests/test_ignorewhitespace.py

@@ -70,8 +70,12 @@ def test_check_ignore_whitespace(client, live_server, measure_memory_usage):
 
     # Add our URL to the import page
     test_url = url_for('test_endpoint', _external=True)
-    uuid = client.application.config.get('DATASTORE').add_watch(url=test_url)
-    client.get(url_for("ui.form_watch_checknow"), follow_redirects=True)
+    res = client.post(
+        url_for("imports.import_page"),
+        data={"urls": test_url},
+        follow_redirects=True
+    )
+    assert b"1 Imported" in res.data
 
     time.sleep(sleep_time_for_fetch_thread)
     # Trigger a check
@@ -85,7 +89,7 @@ def test_check_ignore_whitespace(client, live_server, measure_memory_usage):
     # Give the thread time to pick it up
     time.sleep(sleep_time_for_fetch_thread)
 
-    # It should report nothing found (no new 'has-unread-changes' class)
+    # It should report nothing found (no new 'unviewed' class)
     res = client.get(url_for("watchlist.index"))
-    assert b'has-unread-changes' not in res.data
+    assert b'unviewed' not in res.data
     assert b'/test-endpoint' in res.data

changedetectionio/tests/test_import.py

@@ -5,7 +5,7 @@ import time
 
 from flask import url_for
 
-from .util import live_server_setup, wait_for_all_checks, delete_all_watches
+from .util import live_server_setup, wait_for_all_checks
 
 
 # def test_setup(client, live_server, measure_memory_usage):
@@ -28,7 +28,7 @@ https://example.com tag1, other tag"""
     assert b"3 Imported" in res.data
     assert b"tag1" in res.data
     assert b"other tag" in res.data
-    delete_all_watches(client)
+    res = client.get(url_for("ui.form_delete", uuid="all"), follow_redirects=True)
 
     # Clear flask alerts
     res = client.get( url_for("watchlist.index"))
@@ -53,7 +53,7 @@ def xtest_import_skip_url(client, live_server, measure_memory_usage):
     assert b"1 Imported" in res.data
     assert b"ht000000broken" in res.data
     assert b"1 Skipped" in res.data
-    delete_all_watches(client)
+    res = client.get(url_for("ui.form_delete", uuid="all"), follow_redirects=True)
     # Clear flask alerts
     res = client.get( url_for("watchlist.index"))
 
@@ -119,7 +119,7 @@ def test_import_distillio(client, live_server, measure_memory_usage):
     assert b"nice stuff" in res.data
     assert b"nerd-news" in res.data
 
-    delete_all_watches(client)
+    res = client.get(url_for("ui.form_delete", uuid="all"), follow_redirects=True)
     # Clear flask alerts
     res = client.get(url_for("watchlist.index"))
 
@@ -169,7 +169,8 @@ def test_import_custom_xlsx(client, live_server, measure_memory_usage):
             assert filters[0] == '/html[1]/body[1]/div[4]/div[1]/div[1]/div[1]||//*[@id=\'content\']/div[3]/div[1]/div[1]||//*[@id=\'content\']/div[1]'
             assert watch.get('time_between_check') == {'weeks': 0, 'days': 1, 'hours': 6, 'minutes': 24, 'seconds': 0}
 
-    delete_all_watches(client)
+    res = client.get(url_for("ui.form_delete", uuid="all"), follow_redirects=True)
+    assert b'Deleted' in res.data
 
 def test_import_watchete_xlsx(client, live_server, measure_memory_usage):
     """Test can upload a excel spreadsheet and the watches are created correctly"""
@@ -213,4 +214,5 @@ def test_import_watchete_xlsx(client, live_server, measure_memory_usage):
         if watch.get('title') == 'system default website':
             assert watch.get('fetch_backend') == 'system' # uses default if blank
 
-    delete_all_watches(client)
+    res = client.get(url_for("ui.form_delete", uuid="all"), follow_redirects=True)
+    assert b'Deleted' in res.data

changedetectionio/tests/test_jinja2.py

@@ -26,7 +26,7 @@ def test_jinja2_in_url_query(client, live_server, measure_memory_usage):
     assert b"Watch added" in res.data
     wait_for_all_checks(client)
 
-    # It should report nothing found (no new 'has-unread-changes' class)
+    # It should report nothing found (no new 'unviewed' class)
     res = client.get(
         url_for("ui.ui_views.preview_page", uuid="first"),
         follow_redirects=True
@@ -51,7 +51,7 @@ def test_jinja2_security_url_query(client, live_server, measure_memory_usage):
     assert b"Watch added" in res.data
     wait_for_all_checks(client)
 
-    # It should report nothing found (no new 'has-unread-changes' class)
+    # It should report nothing found (no new 'unviewed' class)
     res = client.get(url_for("watchlist.index"))
     assert b'is invalid and cannot be used' in res.data
     # Some of the spewed output from the subclasses

changedetectionio/tests/test_jsonpath_jq_selector.py

@@ -3,7 +3,7 @@
 
 import time
 from flask import url_for, escape
-from . util import live_server_setup, wait_for_all_checks, delete_all_watches
+from . util import live_server_setup, wait_for_all_checks
 import pytest
 jq_support = True
 
@@ -205,10 +205,16 @@ def test_check_json_without_filter(client, live_server, measure_memory_usage):
     # and be sure it doesn't get chewed up by instriptis
     set_json_response_with_html()
 
+    # Give the endpoint time to spin up
+    time.sleep(1)
+
     # Add our URL to the import page
     test_url = url_for('test_endpoint', content_type="application/json", _external=True)
-    uuid = client.application.config.get('DATASTORE').add_watch(url=test_url)
-    client.get(url_for("ui.form_watch_checknow"), follow_redirects=True)
+    client.post(
+        url_for("imports.import_page"),
+        data={"urls": test_url},
+        follow_redirects=True
+    )
 
     # Give the thread time to pick it up
     wait_for_all_checks(client)
@@ -222,16 +228,23 @@ def test_check_json_without_filter(client, live_server, measure_memory_usage):
     assert b'"html": "<b>"' in res.data
     assert res.data.count(b'{') >= 2
 
-    delete_all_watches(client)
+    res = client.get(url_for("ui.form_delete", uuid="all"), follow_redirects=True)
+    assert b'Deleted' in res.data
 
 def check_json_filter(json_filter, client, live_server):
     set_original_response()
 
+    # Give the endpoint time to spin up
+    time.sleep(1)
 
     # Add our URL to the import page
     test_url = url_for('test_endpoint', content_type="application/json", _external=True)
-    uuid = client.application.config.get('DATASTORE').add_watch(url=test_url)
-    client.get(url_for("ui.form_watch_checknow"), follow_redirects=True)
+    res = client.post(
+        url_for("imports.import_page"),
+        data={"urls": test_url},
+        follow_redirects=True
+    )
+    assert b"1 Imported" in res.data
 
     # Give the thread time to pick it up
     wait_for_all_checks(client)
@@ -244,8 +257,7 @@ def check_json_filter(json_filter, client, live_server):
               "url": test_url,
               "tags": "",
               "headers": "",
-              "fetch_backend": "html_requests",
-              "time_between_check_use_default": "y"
+              "fetch_backend": "html_requests"
               },
         follow_redirects=True
     )
@@ -267,9 +279,9 @@ def check_json_filter(json_filter, client, live_server):
     # Give the thread time to pick it up
     wait_for_all_checks(client)
 
-    # It should have 'has-unread-changes' still
+    # It should have 'unviewed' still
     res = client.get(url_for("watchlist.index"))
-    assert b'has-unread-changes' in res.data
+    assert b'unviewed' in res.data
 
     # Should not see this, because its not in the JSONPath we entered
     res = client.get(url_for("ui.ui_views.diff_history_page", uuid="first"))
@@ -278,7 +290,8 @@ def check_json_filter(json_filter, client, live_server):
     # And #462 - check we see the proper utf-8 string there
     assert "Örnsköldsvik".encode('utf-8') in res.data
 
-    delete_all_watches(client)
+    res = client.get(url_for("ui.form_delete", uuid="all"), follow_redirects=True)
+    assert b'Deleted' in res.data
 
 def test_check_jsonpath_filter(client, live_server, measure_memory_usage):
     check_json_filter('json:boss.name', client, live_server)
@@ -299,8 +312,12 @@ def check_json_filter_bool_val(json_filter, client, live_server):
 
     test_url = url_for('test_endpoint', content_type="application/json", _external=True)
 
-    uuid = client.application.config.get('DATASTORE').add_watch(url=test_url)
-    client.get(url_for("ui.form_watch_checknow"), follow_redirects=True)
+    res = client.post(
+        url_for("imports.import_page"),
+        data={"urls": test_url},
+        follow_redirects=True
+    )
+    assert b"1 Imported" in res.data
 
     wait_for_all_checks(client)
     # Goto the edit page, add our ignore text
@@ -311,8 +328,7 @@ def check_json_filter_bool_val(json_filter, client, live_server):
               "url": test_url,
               "tags": "",
               "headers": "",
-              "fetch_backend": "html_requests",
-              "time_between_check_use_default": "y"
+              "fetch_backend": "html_requests"
               },
         follow_redirects=True
     )
@@ -332,7 +348,8 @@ def check_json_filter_bool_val(json_filter, client, live_server):
     # But the change should be there, tho its hard to test the change was detected because it will show old and new versions
     assert b'false' in res.data
 
-    delete_all_watches(client)
+    res = client.get(url_for("ui.form_delete", uuid="all"), follow_redirects=True)
+    assert b'Deleted' in res.data
 
 def test_check_jsonpath_filter_bool_val(client, live_server, measure_memory_usage):
     check_json_filter_bool_val("json:$['available']", client, live_server)
@@ -358,8 +375,12 @@ def check_json_ext_filter(json_filter, client, live_server):
 
     # Add our URL to the import page
     test_url = url_for('test_endpoint', content_type="application/json", _external=True)
-    uuid = client.application.config.get('DATASTORE').add_watch(url=test_url)
-    client.get(url_for("ui.form_watch_checknow"), follow_redirects=True)
+    res = client.post(
+        url_for("imports.import_page"),
+        data={"urls": test_url},
+        follow_redirects=True
+    )
+    assert b"1 Imported" in res.data
 
     # Give the thread time to pick it up
     wait_for_all_checks(client)
@@ -372,8 +393,7 @@ def check_json_ext_filter(json_filter, client, live_server):
               "url": test_url,
               "tags": "",
               "headers": "",
-              "fetch_backend": "html_requests",
-              "time_between_check_use_default": "y"
+              "fetch_backend": "html_requests"
               },
         follow_redirects=True
     )
@@ -395,14 +415,14 @@ def check_json_ext_filter(json_filter, client, live_server):
     # Give the thread time to pick it up
     wait_for_all_checks(client)
 
-    # It should have 'has-unread-changes'
+    # It should have 'unviewed'
     res = client.get(url_for("watchlist.index"))
-    assert b'has-unread-changes' in res.data
+    assert b'unviewed' in res.data
 
     res = client.get(url_for("ui.ui_views.preview_page", uuid="first"))
 
     # We should never see 'ForSale' because we are selecting on 'Sold' in the rule,
-    # But we should know it triggered ('has-unread-changes' assert above)
+    # But we should know it triggered ('unviewed' assert above)
     assert b'ForSale' not in res.data
     assert b'Sold' in res.data
 
@@ -413,7 +433,8 @@ def check_json_ext_filter(json_filter, client, live_server):
     assert b'ForSale' in res.data
     assert b'Sold' in res.data
 
-    delete_all_watches(client)
+    res = client.get(url_for("ui.form_delete", uuid="all"), follow_redirects=True)
+    assert b'Deleted' in res.data
 
 def test_ignore_json_order(client, live_server, measure_memory_usage):
     # A change in order shouldn't trigger a notification
@@ -424,8 +445,12 @@ def test_ignore_json_order(client, live_server, measure_memory_usage):
 
     # Add our URL to the import page
     test_url = url_for('test_endpoint', content_type="application/json", _external=True)
-    uuid = client.application.config.get('DATASTORE').add_watch(url=test_url)
-    client.get(url_for("ui.form_watch_checknow"), follow_redirects=True)
+    res = client.post(
+        url_for("imports.import_page"),
+        data={"urls": test_url},
+        follow_redirects=True
+    )
+    assert b"1 Imported" in res.data
 
     wait_for_all_checks(client)
 
@@ -437,7 +462,7 @@ def test_ignore_json_order(client, live_server, measure_memory_usage):
     wait_for_all_checks(client)
 
     res = client.get(url_for("watchlist.index"))
-    assert b'has-unread-changes' not in res.data
+    assert b'unviewed' not in res.data
 
     # Just to be sure it still works
     with open("test-datastore/endpoint-content.txt", "w") as f:
@@ -448,9 +473,10 @@ def test_ignore_json_order(client, live_server, measure_memory_usage):
     wait_for_all_checks(client)
 
     res = client.get(url_for("watchlist.index"))
-    assert b'has-unread-changes' in res.data
+    assert b'unviewed' in res.data
 
-    delete_all_watches(client)
+    res = client.get(url_for("ui.form_delete", uuid="all"), follow_redirects=True)
+    assert b'Deleted' in res.data
 
 def test_correct_header_detect(client, live_server, measure_memory_usage):
     # Like in https://github.com/dgtlmoon/changedetection.io/pull/1593
@@ -461,8 +487,12 @@ def test_correct_header_detect(client, live_server, measure_memory_usage):
     # Add our URL to the import page
     # Check weird casing is cleaned up and detected also
     test_url = url_for('test_endpoint', content_type="aPPlication/JSon", uppercase_headers=True, _external=True)
-    uuid = client.application.config.get('DATASTORE').add_watch(url=test_url)
-    client.get(url_for("ui.form_watch_checknow"), follow_redirects=True)
+    res = client.post(
+        url_for("imports.import_page"),
+        data={"urls": test_url},
+        follow_redirects=True
+    )
+    assert b"1 Imported" in res.data
     wait_for_all_checks(client)
     res = client.get(url_for("watchlist.index"))
 
@@ -477,7 +507,8 @@ def test_correct_header_detect(client, live_server, measure_memory_usage):
     assert b'"hello": 123,' in res.data
     assert b'"world": 123' in res.data
 
-    delete_all_watches(client)
+    res = client.get(url_for("ui.form_delete", uuid="all"), follow_redirects=True)
+    assert b'Deleted' in res.data
 
 def test_check_jsonpath_ext_filter(client, live_server, measure_memory_usage):
     check_json_ext_filter('json:$[?(@.status==Sold)]', client, live_server)

changedetectionio/tests/test_live_preview.py

@@ -1,7 +1,7 @@
 #!/usr/bin/env python3
 
 from flask import url_for
-from changedetectionio.tests.util import live_server_setup, wait_for_all_checks, extract_UUID_from_client, delete_all_watches
+from changedetectionio.tests.util import live_server_setup, wait_for_all_checks, extract_UUID_from_client
 
 
 def set_response():
@@ -38,7 +38,6 @@ def test_content_filter_live_preview(client, live_server, measure_memory_usage):
             "ignore_text": "something to ignore",
             "trigger_text": "something to trigger",
             "url": test_url,
-            "time_between_check_use_default": "y",
         },
         follow_redirects=True
     )
@@ -75,4 +74,5 @@ def test_content_filter_live_preview(client, live_server, measure_memory_usage):
     assert reply.get('ignore_line_numbers') == [2]  # Ignored - "socks" on line 2
     assert reply.get('trigger_line_numbers') == [1]  # Triggers "Awesome" in line 1
 
-    delete_all_watches(client)
+    res = client.get(url_for("ui.form_delete", uuid="all"), follow_redirects=True)
+    assert b'Deleted' in res.data

changedetectionio/tests/test_nonrenderable_pages.py

@@ -1,7 +1,7 @@
 #!/usr/bin/env python3
 
 from flask import url_for
-from .util import set_original_response, set_modified_response, live_server_setup, wait_for_all_checks, delete_all_watches
+from .util import set_original_response, set_modified_response, live_server_setup, wait_for_all_checks
 import time
 
 
@@ -40,9 +40,9 @@ def test_check_basic_change_detection_functionality(client, live_server, measure
 
     wait_for_all_checks(client)
 
-    # It should report nothing found (no new 'has-unread-changes' class)
+    # It should report nothing found (no new 'unviewed' class)
     res = client.get(url_for("watchlist.index"))
-    assert b'has-unread-changes' not in res.data
+    assert b'unviewed' not in res.data
 
 
     #####################
@@ -62,9 +62,9 @@ def test_check_basic_change_detection_functionality(client, live_server, measure
     # Give the thread time to pick it up
     wait_for_all_checks(client)
 
-    # It should report nothing found (no new 'has-unread-changes' class)
+    # It should report nothing found (no new 'unviewed' class)
     res = client.get(url_for("watchlist.index"))
-    assert b'has-unread-changes' not in res.data
+    assert b'unviewed' not in res.data
 
     uuid = next(iter(live_server.app.config['DATASTORE'].data['watching']))
     watch = live_server.app.config['DATASTORE'].data['watching'][uuid]
@@ -92,9 +92,9 @@ def test_check_basic_change_detection_functionality(client, live_server, measure
     # Give the thread time to pick it up
     wait_for_all_checks(client)
 
-    # It should report nothing found (no new 'has-unread-changes' class)
+    # It should report nothing found (no new 'unviewed' class)
     res = client.get(url_for("watchlist.index"))
-    assert b'has-unread-changes' in res.data
+    assert b'unviewed' in res.data
     client.get(url_for("ui.mark_all_viewed"), follow_redirects=True)
     time.sleep(0.2)
 
@@ -108,10 +108,11 @@ def test_check_basic_change_detection_functionality(client, live_server, measure
 
     wait_for_all_checks(client)
     res = client.get(url_for("watchlist.index"))
-    assert b'has-unread-changes' in res.data # A change should have registered because empty_pages_are_a_change is ON
+    assert b'unviewed' in res.data # A change should have registered because empty_pages_are_a_change is ON
     assert b'fetch-error' not in res.data
 
     #
     # Cleanup everything
-    delete_all_watches(client)
+    res = client.get(url_for("ui.form_delete", uuid="all"), follow_redirects=True)
+    assert b'Deleted' in res.data
 

changedetectionio/tests/test_notification.py

@@ -108,8 +108,7 @@ def test_check_notification(client, live_server, measure_memory_usage):
         "tags": "my tag, my second tag",
         "title": "my title",
         "headers": "",
-        "fetch_backend": "html_requests",
-        "time_between_check_use_default": "y"})
+        "fetch_backend": "html_requests"})
 
     res = client.post(
         url_for("ui.ui_edit.edit_page", uuid="first"),
@@ -226,8 +225,7 @@ def test_check_notification(client, live_server, measure_memory_usage):
         "notification_title": '',
         "notification_body": '',
         "notification_format": default_notification_format,
-        "fetch_backend": "html_requests",
-        "time_between_check_use_default": "y"},
+        "fetch_backend": "html_requests"},
         follow_redirects=True
     )
     assert b"Updated watch." in res.data

changedetectionio/tests/test_notification_errors.py

@@ -36,8 +36,7 @@ def test_check_notification_error_handling(client, live_server, measure_memory_u
               "title": "",
               "headers": "",
               "time_between_check-minutes": "180",
-              "fetch_backend": "html_requests",
-              "time_between_check_use_default": "y"},
+              "fetch_backend": "html_requests"},
         follow_redirects=True
     )
     assert b"Updated watch." in res.data

changedetectionio/tests/test_obfuscations.py

@@ -24,8 +24,12 @@ def test_obfuscations(client, live_server, measure_memory_usage):
     time.sleep(1)
     # Add our URL to the import page
     test_url = url_for('test_endpoint', _external=True)
-    uuid = client.application.config.get('DATASTORE').add_watch(url=test_url)
-    client.get(url_for("ui.form_watch_checknow"), follow_redirects=True)
+    res = client.post(
+        url_for("imports.import_page"),
+        data={"urls": test_url},
+        follow_redirects=True
+    )
+    assert b"1 Imported" in res.data
 
     # Give the thread time to pick it up
     time.sleep(3)

changedetectionio/tests/test_pdf.py

@@ -8,30 +8,30 @@ from .util import set_original_response, set_modified_response, live_server_setu
 # `subtractive_selectors` should still work in `source:` type requests
 def test_fetch_pdf(client, live_server, measure_memory_usage):
     import shutil
-    import os
-
     shutil.copy("tests/test.pdf", "test-datastore/endpoint-test.pdf")
-    first_version_size = os.path.getsize("test-datastore/endpoint-test.pdf")
 
+   #  live_server_setup(live_server) # Setup on conftest per function
     test_url = url_for('test_pdf_endpoint', _external=True)
-    uuid = client.application.config.get('DATASTORE').add_watch(url=test_url)
-    client.get(url_for("ui.form_watch_checknow"), follow_redirects=True)
+    # Add our URL to the import page
+    res = client.post(
+        url_for("imports.import_page"),
+        data={"urls": test_url},
+        follow_redirects=True
+    )
+
+    assert b"1 Imported" in res.data
+
 
     wait_for_all_checks(client)
 
-    watch = live_server.app.config['DATASTORE'].data['watching'][uuid]
-    dates = list(watch.history.keys())
-    snapshot_contents = watch.get_history_snapshot(dates[0])
+    res = client.get(
+        url_for("ui.ui_views.preview_page", uuid="first"),
+        follow_redirects=True
+    )
 
     # PDF header should not be there (it was converted to text)
-    assert 'PDF' not in snapshot_contents
-    # Was converted away from HTML
-    assert 'pdftohtml' not in snapshot_contents.lower() # Generator tag shouldnt be there
-    assert f'Original file size - {first_version_size}' in snapshot_contents
-    assert 'html' not in snapshot_contents.lower() # is converted from html
-    assert 'body' not in snapshot_contents.lower()  # is converted from html
-    # And our text content was there
-    assert 'hello world' in snapshot_contents
+    assert b'PDF' not in res.data[:10]
+    assert b'hello world' in res.data
 
     # So we know if the file changes in other ways
     import hashlib
@@ -39,7 +39,8 @@ def test_fetch_pdf(client, live_server, measure_memory_usage):
     # We should have one
     assert len(original_md5) >0
     # And it's going to be in the document
-    assert f'Document checksum - {original_md5}' in snapshot_contents
+    assert b'Document checksum - '+bytes(str(original_md5).encode('utf-8')) in res.data
+
 
     shutil.copy("tests/test2.pdf", "test-datastore/endpoint-test.pdf")
     changed_md5 = hashlib.md5(open("test-datastore/endpoint-test.pdf", 'rb').read()).hexdigest().upper()
@@ -48,9 +49,9 @@ def test_fetch_pdf(client, live_server, measure_memory_usage):
 
     wait_for_all_checks(client)
 
-    # Now something should be ready, indicated by having a 'has-unread-changes' class
+    # Now something should be ready, indicated by having a 'unviewed' class
     res = client.get(url_for("watchlist.index"))
-    assert b'has-unread-changes' in res.data
+    assert b'unviewed' in res.data
 
     # The original checksum should be not be here anymore (cdio adds it to the bottom of the text)
 
@@ -62,6 +63,7 @@ def test_fetch_pdf(client, live_server, measure_memory_usage):
     assert original_md5.encode('utf-8') not in res.data
     assert changed_md5.encode('utf-8') in res.data
 
+
     res = client.get(
         url_for("ui.ui_views.diff_history_page", uuid="first"),
         follow_redirects=True
@@ -69,16 +71,6 @@ def test_fetch_pdf(client, live_server, measure_memory_usage):
 
     assert original_md5.encode('utf-8') in res.data
     assert changed_md5.encode('utf-8') in res.data
+
     assert b'here is a change' in res.data
-
-
-    dates = list(watch.history.keys())
-    # new snapshot was also OK, no HTML
-    snapshot_contents = watch.get_history_snapshot(dates[1])
-    assert 'html' not in snapshot_contents.lower()
-    assert f'Original file size - {os.path.getsize("test-datastore/endpoint-test.pdf")}' in snapshot_contents
-    assert f'here is a change' in snapshot_contents
-    assert os.path.getsize("test-datastore/endpoint-test.pdf") != first_version_size # And the disk change worked
-
-
     

changedetectionio/tests/test_preview_endpoints.py

@@ -13,8 +13,13 @@ def test_fetch_pdf(client, live_server, measure_memory_usage):
    #  live_server_setup(live_server) # Setup on conftest per function
     test_url = url_for('test_pdf_endpoint', _external=True)
     # Add our URL to the import page
-    uuid = client.application.config.get('DATASTORE').add_watch(url=test_url)
-    client.get(url_for("ui.form_watch_checknow"), follow_redirects=True)
+    res = client.post(
+        url_for("imports.import_page"),
+        data={"urls": test_url},
+        follow_redirects=True
+    )
+
+    assert b"1 Imported" in res.data
 
     wait_for_all_checks(client)
 
@@ -42,9 +47,9 @@ def test_fetch_pdf(client, live_server, measure_memory_usage):
 
     wait_for_all_checks(client)
 
-    # Now something should be ready, indicated by having a 'has-unread-changes' class
+    # Now something should be ready, indicated by having a 'unviewed' class
     res = client.get(url_for("watchlist.index"))
-    assert b'has-unread-changes' in res.data
+    assert b'unviewed' in res.data
 
     # The original checksum should be not be here anymore (cdio adds it to the bottom of the text)
 

changedetectionio/tests/test_request.py

@@ -2,7 +2,7 @@ import json
 import os
 import time
 from flask import url_for
-from . util import set_original_response, set_modified_response, live_server_setup, wait_for_all_checks, extract_UUID_from_client, delete_all_watches
+from . util import set_original_response, set_modified_response, live_server_setup, wait_for_all_checks, extract_UUID_from_client
 
 
 
@@ -17,13 +17,21 @@ def test_headers_in_request(client, live_server, measure_memory_usage):
         test_url = test_url.replace('localhost', 'changedet')
 
     # Add the test URL twice, we will check
-    uuid = client.application.config.get('DATASTORE').add_watch(url=test_url)
-    client.get(url_for("ui.form_watch_checknow"), follow_redirects=True)
+    res = client.post(
+        url_for("imports.import_page"),
+        data={"urls": test_url},
+        follow_redirects=True
+    )
+    assert b"1 Imported" in res.data
 
     wait_for_all_checks(client)
 
-    uuid = client.application.config.get('DATASTORE').add_watch(url=test_url)
-    client.get(url_for("ui.form_watch_checknow"), follow_redirects=True)
+    res = client.post(
+        url_for("imports.import_page"),
+        data={"urls": test_url},
+        follow_redirects=True
+    )
+    assert b"1 Imported" in res.data
 
     wait_for_all_checks(client)
     cookie_header = '_ga=GA1.2.1022228332; cookie-preferences=analytics:accepted;'
@@ -36,8 +44,7 @@ def test_headers_in_request(client, live_server, measure_memory_usage):
               "url": test_url,
               "tags": "",
               "fetch_backend": 'html_webdriver' if os.getenv('PLAYWRIGHT_DRIVER_URL') else 'html_requests',
-              "headers": "jinja2:{{ 1+1 }}\nxxx:ooo\ncool:yeah\r\ncookie:"+cookie_header,
-              "time_between_check_use_default": "y"},
+              "headers": "jinja2:{{ 1+1 }}\nxxx:ooo\ncool:yeah\r\ncookie:"+cookie_header},
         follow_redirects=True
     )
     assert b"Updated watch." in res.data
@@ -74,7 +81,8 @@ def test_headers_in_request(client, live_server, measure_memory_usage):
     for k, watch in client.application.config.get('DATASTORE').data.get('watching').items():
         assert 'custom' in watch.get('remote_server_reply') # added in util.py
 
-    delete_all_watches(client)
+    res = client.get(url_for("ui.form_delete", uuid="all"), follow_redirects=True)
+    assert b'Deleted' in res.data
 
 def test_body_in_request(client, live_server, measure_memory_usage):
 
@@ -84,8 +92,12 @@ def test_body_in_request(client, live_server, measure_memory_usage):
         # Because its no longer calling back to localhost but from the browser container, set in test-only.yml
         test_url = test_url.replace('localhost', 'cdio')
 
-    uuid = client.application.config.get('DATASTORE').add_watch(url=test_url)
-    client.get(url_for("ui.form_watch_checknow"), follow_redirects=True)
+    res = client.post(
+        url_for("imports.import_page"),
+        data={"urls": test_url},
+        follow_redirects=True
+    )
+    assert b"1 Imported" in res.data
 
     wait_for_all_checks(client)
 
@@ -97,8 +109,7 @@ def test_body_in_request(client, live_server, measure_memory_usage):
               "tags": "",
               "method": "POST",
               "fetch_backend": "html_requests",
-              "body": "something something",
-              "time_between_check_use_default": "y"},
+              "body": "something something"},
         follow_redirects=True
     )
     assert b"Updated watch." in res.data
@@ -115,8 +126,7 @@ def test_body_in_request(client, live_server, measure_memory_usage):
               "tags": "",
               "method": "POST",
               "fetch_backend": "html_requests",
-              "body": body_value,
-              "time_between_check_use_default": "y"},
+              "body": body_value},
         follow_redirects=True
     )
     assert b"Updated watch." in res.data
@@ -137,8 +147,12 @@ def test_body_in_request(client, live_server, measure_memory_usage):
 
     ####### data sanity checks
     # Add the test URL twice, we will check
-    uuid = client.application.config.get('DATASTORE').add_watch(url=test_url)
-    client.get(url_for("ui.form_watch_checknow"), follow_redirects=True)
+    res = client.post(
+        url_for("imports.import_page"),
+        data={"urls": test_url},
+        follow_redirects=True
+    )
+    assert b"1 Imported" in res.data
     wait_for_all_checks(client)
     watches_with_body = 0
     with open('test-datastore/url-watches.json') as f:
@@ -158,12 +172,12 @@ def test_body_in_request(client, live_server, measure_memory_usage):
               "tags": "",
               "method": "GET",
               "fetch_backend": "html_requests",
-              "body": "invalid",
-              "time_between_check_use_default": "y"},
+              "body": "invalid"},
         follow_redirects=True
     )
     assert b"Body must be empty when Request Method is set to GET" in res.data
-    delete_all_watches(client)
+    res = client.get(url_for("ui.form_delete", uuid="all"), follow_redirects=True)
+    assert b'Deleted' in res.data
 
 def test_method_in_request(client, live_server, measure_memory_usage):
     # Add our URL to the import page
@@ -173,12 +187,20 @@ def test_method_in_request(client, live_server, measure_memory_usage):
         test_url = test_url.replace('localhost', 'cdio')
 
     # Add the test URL twice, we will check
-    uuid = client.application.config.get('DATASTORE').add_watch(url=test_url)
-    client.get(url_for("ui.form_watch_checknow"), follow_redirects=True)
+    res = client.post(
+        url_for("imports.import_page"),
+        data={"urls": test_url},
+        follow_redirects=True
+    )
+    assert b"1 Imported" in res.data
 
     wait_for_all_checks(client)
-    uuid = client.application.config.get('DATASTORE').add_watch(url=test_url)
-    client.get(url_for("ui.form_watch_checknow"), follow_redirects=True)
+    res = client.post(
+        url_for("imports.import_page"),
+        data={"urls": test_url},
+        follow_redirects=True
+    )
+    assert b"1 Imported" in res.data
 
     wait_for_all_checks(client)
 
@@ -189,8 +211,7 @@ def test_method_in_request(client, live_server, measure_memory_usage):
             "url": test_url,
             "tags": "",
             "fetch_backend": "html_requests",
-            "method": "invalid",
-            "time_between_check_use_default": "y"},
+            "method": "invalid"},
         follow_redirects=True
     )
     assert b"Not a valid choice" in res.data
@@ -202,8 +223,7 @@ def test_method_in_request(client, live_server, measure_memory_usage):
             "url": test_url,
             "tags": "",
             "fetch_backend": "html_requests",
-            "method": "PATCH",
-            "time_between_check_use_default": "y"},
+            "method": "PATCH"},
         follow_redirects=True
     )
     assert b"Updated watch." in res.data
@@ -232,7 +252,8 @@ def test_method_in_request(client, live_server, measure_memory_usage):
     # Should be only one with method set to PATCH
     assert watches_with_method == 1
 
-    delete_all_watches(client)
+    res = client.get(url_for("ui.form_delete", uuid="all"), follow_redirects=True)
+    assert b'Deleted' in res.data
 
 # Re #2408 - user-agent override test, also should handle case-insensitive header deduplication
 def test_ua_global_override(client, live_server, measure_memory_usage):
@@ -250,8 +271,12 @@ def test_ua_global_override(client, live_server, measure_memory_usage):
     )
     assert b'Settings updated' in res.data
 
-    uuid = client.application.config.get('DATASTORE').add_watch(url=test_url)
-    client.get(url_for("ui.form_watch_checknow"), follow_redirects=True)
+    res = client.post(
+        url_for("imports.import_page"),
+        data={"urls": test_url},
+        follow_redirects=True
+    )
+    assert b"1 Imported" in res.data
 
     wait_for_all_checks(client)
     res = client.get(
@@ -272,8 +297,7 @@ def test_ua_global_override(client, live_server, measure_memory_usage):
             "tags": "testtag",
             "fetch_backend": 'html_requests',
             # Important - also test case-insensitive
-            "headers": "User-AGent: agent-from-watch",
-            "time_between_check_use_default": "y"},
+            "headers": "User-AGent: agent-from-watch"},
         follow_redirects=True
     )
     assert b"Updated watch." in res.data
@@ -284,7 +308,8 @@ def test_ua_global_override(client, live_server, measure_memory_usage):
     )
     assert b"agent-from-watch" in res.data
     assert b"html-requests-user-agent" not in res.data
-    delete_all_watches(client)
+    res = client.get(url_for("ui.form_delete", uuid="all"), follow_redirects=True)
+    assert b'Deleted' in res.data
 
 def test_headers_textfile_in_request(client, live_server, measure_memory_usage):
     
@@ -324,8 +349,12 @@ def test_headers_textfile_in_request(client, live_server, measure_memory_usage):
     assert b"requests-default_ua-html_requests" in res.data
 
     # Add the test URL twice, we will check
-    uuid = client.application.config.get('DATASTORE').add_watch(url=test_url)
-    client.get(url_for("ui.form_watch_checknow"), follow_redirects=True)
+    res = client.post(
+        url_for("imports.import_page"),
+        data={"urls": test_url},
+        follow_redirects=True
+    )
+    assert b"1 Imported" in res.data
 
     wait_for_all_checks(client)
 
@@ -336,8 +365,7 @@ def test_headers_textfile_in_request(client, live_server, measure_memory_usage):
             "url": test_url,
             "tags": "testtag",
             "fetch_backend": 'html_webdriver' if os.getenv('PLAYWRIGHT_DRIVER_URL') else 'html_requests',
-            "headers": "xxx:ooo\ncool:yeah\r\n",
-            "time_between_check_use_default": "y"},
+            "headers": "xxx:ooo\ncool:yeah\r\n"},
         follow_redirects=True
     )
     assert b"Updated watch." in res.data
@@ -393,22 +421,26 @@ def test_headers_textfile_in_request(client, live_server, measure_memory_usage):
         assert "User-Agent:".encode('utf-8') + requests_ua.encode('utf-8') in res.data
 
     # unlink headers.txt on start/stop
-    delete_all_watches(client)
+    res = client.get(url_for("ui.form_delete", uuid="all"), follow_redirects=True)
+    assert b'Deleted' in res.data
 
-def test_headers_validation(client, live_server, measure_memory_usage):
+def test_headers_validation(client, live_server):
     
 
     test_url = url_for('test_headers', _external=True)
-    uuid = client.application.config.get('DATASTORE').add_watch(url=test_url)
-    client.get(url_for("ui.form_watch_checknow"), follow_redirects=True)
+    res = client.post(
+        url_for("imports.import_page"),
+        data={"urls": test_url},
+        follow_redirects=True
+    )
+    assert b"1 Imported" in res.data
 
     res = client.post(
         url_for("ui.ui_edit.edit_page", uuid="first"),
         data={
             "url": test_url,
             "fetch_backend": 'html_requests',
-            "headers": "User-AGent agent-from-watch\r\nsadfsadfsadfsdaf\r\n:foobar",
-            "time_between_check_use_default": "y"},
+            "headers": "User-AGent agent-from-watch\r\nsadfsadfsadfsdaf\r\n:foobar"},
         follow_redirects=True
     )
 

changedetectionio/tests/test_restock_itemprop.py

@@ -3,7 +3,7 @@ import os
 import time
 
 from flask import url_for
-from .util import live_server_setup, wait_for_all_checks, wait_for_notification_endpoint_output, extract_UUID_from_client, delete_all_watches
+from .util import live_server_setup, wait_for_all_checks, wait_for_notification_endpoint_output, extract_UUID_from_client
 from ..notification import default_notification_format
 
 instock_props = [
@@ -44,11 +44,11 @@ def set_original_response(props_markup='', price="121.95"):
 
 
 
-# def test_setup(client, live_server, measure_memory_usage):
+# def test_setup(client, live_server):
 
    #  live_server_setup(live_server) # Setup on conftest per function
 
-def test_restock_itemprop_basic(client, live_server, measure_memory_usage):
+def test_restock_itemprop_basic(client, live_server):
 
     
 
@@ -69,7 +69,8 @@ def test_restock_itemprop_basic(client, live_server, measure_memory_usage):
         assert b'has-restock-info' in res.data
         assert b' in-stock' in res.data
         assert b' not-in-stock' not in res.data
-        delete_all_watches(client)
+        res = client.get(url_for("ui.form_delete", uuid="all"), follow_redirects=True)
+        assert b'Deleted' in res.data
 
 
     for p in out_of_stock_props:
@@ -84,9 +85,10 @@ def test_restock_itemprop_basic(client, live_server, measure_memory_usage):
 
         assert b'has-restock-info not-in-stock' in res.data
 
-        delete_all_watches(client)
+        res = client.get(url_for("ui.form_delete", uuid="all"), follow_redirects=True)
+        assert b'Deleted' in res.data
 
-def test_itemprop_price_change(client, live_server, measure_memory_usage):
+def test_itemprop_price_change(client, live_server):
     
 
     # Out of the box 'Follow price changes' should be ON
@@ -110,7 +112,7 @@ def test_itemprop_price_change(client, live_server, measure_memory_usage):
     wait_for_all_checks(client)
     res = client.get(url_for("watchlist.index"))
     assert b'180.45' in res.data
-    assert b'has-unread-changes' in res.data
+    assert b'unviewed' in res.data
     client.get(url_for("ui.mark_all_viewed"), follow_redirects=True)
     time.sleep(0.2)
 
@@ -119,7 +121,7 @@ def test_itemprop_price_change(client, live_server, measure_memory_usage):
     set_original_response(props_markup=instock_props[0], price='120.45')
     res = client.post(
         url_for("ui.ui_edit.edit_page", uuid="first"),
-        data={"restock_settings-follow_price_changes": "", "url": test_url, "tags": "", "headers": "", 'fetch_backend': "html_requests", "time_between_check_use_default": "y"},
+        data={"restock_settings-follow_price_changes": "", "url": test_url, "tags": "", "headers": "", 'fetch_backend': "html_requests"},
         follow_redirects=True
     )
     assert b"Updated watch." in res.data
@@ -127,14 +129,16 @@ def test_itemprop_price_change(client, live_server, measure_memory_usage):
     wait_for_all_checks(client)
     res = client.get(url_for("watchlist.index"))
     assert b'120.45' in res.data
-    assert b'has-unread-changes' not in res.data
+    assert b'unviewed' not in res.data
 
 
-    delete_all_watches(client)
+    res = client.get(url_for("ui.form_delete", uuid="all"), follow_redirects=True)
+    assert b'Deleted' in res.data
 
 def _run_test_minmax_limit(client, extra_watch_edit_form):
 
-    delete_all_watches(client)
+    res = client.get(url_for("ui.form_delete", uuid="all"), follow_redirects=True)
+    assert b'Deleted' in res.data
 
     test_url = url_for('test_endpoint', _external=True)
 
@@ -151,8 +155,7 @@ def _run_test_minmax_limit(client, extra_watch_edit_form):
         "url": test_url,
         "headers": "",
         "time_between_check-hours": 5,
-        'fetch_backend': "html_requests",
-        "time_between_check_use_default": "y"
+        'fetch_backend': "html_requests"
     }
     data.update(extra_watch_edit_form)
     res = client.post(
@@ -174,7 +177,7 @@ def _run_test_minmax_limit(client, extra_watch_edit_form):
     assert b'more than one price detected' not in res.data
     # BUT the new price should show, even tho its within limits
     assert b'1,000.45' or b'1000.45' in res.data #depending on locale
-    assert b'has-unread-changes' not in res.data
+    assert b'unviewed' not in res.data
 
     # price changed to something LESS than min (900), SHOULD be a change
     set_original_response(props_markup=instock_props[0], price='890.45')
@@ -184,7 +187,7 @@ def _run_test_minmax_limit(client, extra_watch_edit_form):
     wait_for_all_checks(client)
     res = client.get(url_for("watchlist.index"))
     assert b'890.45' in res.data
-    assert b'has-unread-changes' in res.data
+    assert b'unviewed' in res.data
 
     client.get(url_for("ui.mark_all_viewed"))
 
@@ -196,7 +199,7 @@ def _run_test_minmax_limit(client, extra_watch_edit_form):
     wait_for_all_checks(client)
     res = client.get(url_for("watchlist.index"))
     assert b'820.45' in res.data
-    assert b'has-unread-changes' in res.data
+    assert b'unviewed' in res.data
     client.get(url_for("ui.mark_all_viewed"))
 
     # price changed to something MORE than max (1100.10), SHOULD be a change
@@ -206,12 +209,13 @@ def _run_test_minmax_limit(client, extra_watch_edit_form):
     res = client.get(url_for("watchlist.index"))
     # Depending on the LOCALE it may be either of these (generally for US/default/etc)
     assert b'1,890.45' in res.data or b'1890.45' in res.data
-    assert b'has-unread-changes' in res.data
+    assert b'unviewed' in res.data
 
-    delete_all_watches(client)
+    res = client.get(url_for("ui.form_delete", uuid="all"), follow_redirects=True)
+    assert b'Deleted' in res.data
 
 
-def test_restock_itemprop_minmax(client, live_server, measure_memory_usage):
+def test_restock_itemprop_minmax(client, live_server):
     
     extras = {
         "restock_settings-follow_price_changes": "y",
@@ -220,7 +224,7 @@ def test_restock_itemprop_minmax(client, live_server, measure_memory_usage):
     }
     _run_test_minmax_limit(client, extra_watch_edit_form=extras)
 
-def test_restock_itemprop_with_tag(client, live_server, measure_memory_usage):
+def test_restock_itemprop_with_tag(client, live_server):
     
 
     res = client.post(
@@ -249,10 +253,11 @@ def test_restock_itemprop_with_tag(client, live_server, measure_memory_usage):
 
 
 
-def test_itemprop_percent_threshold(client, live_server, measure_memory_usage):
+def test_itemprop_percent_threshold(client, live_server):
     
 
-    delete_all_watches(client)
+    res = client.get(url_for("ui.form_delete", uuid="all"), follow_redirects=True)
+    assert b'Deleted' in res.data
 
     test_url = url_for('test_endpoint', _external=True)
 
@@ -273,8 +278,7 @@ def test_itemprop_percent_threshold(client, live_server, measure_memory_usage):
               "url": test_url,
               "tags": "",
               "headers": "",
-              'fetch_backend': "html_requests",
-              "time_between_check_use_default": "y"
+              'fetch_backend': "html_requests"
               },
         follow_redirects=True
     )
@@ -288,7 +292,7 @@ def test_itemprop_percent_threshold(client, live_server, measure_memory_usage):
     wait_for_all_checks(client)
     res = client.get(url_for("watchlist.index"))
     assert b'960.45' in res.data
-    assert b'has-unread-changes' not in res.data
+    assert b'unviewed' not in res.data
 
     # Bigger INCREASE change than the threshold should trigger
     set_original_response(props_markup=instock_props[0], price='1960.45')
@@ -296,7 +300,7 @@ def test_itemprop_percent_threshold(client, live_server, measure_memory_usage):
     wait_for_all_checks(client)
     res = client.get(url_for("watchlist.index"))
     assert b'1,960.45' or b'1960.45' in res.data #depending on locale
-    assert b'has-unread-changes' in res.data
+    assert b'unviewed' in res.data
 
 
     # Small decrease should NOT trigger
@@ -306,16 +310,17 @@ def test_itemprop_percent_threshold(client, live_server, measure_memory_usage):
     wait_for_all_checks(client)
     res = client.get(url_for("watchlist.index"))
     assert b'1,950.45' or b'1950.45' in res.data #depending on locale
-    assert b'has-unread-changes' not in res.data
+    assert b'unviewed' not in res.data
 
 
 
 
-    delete_all_watches(client)
+    res = client.get(url_for("ui.form_delete", uuid="all"), follow_redirects=True)
+    assert b'Deleted' in res.data
 
 
 
-def test_change_with_notification_values(client, live_server, measure_memory_usage):
+def test_change_with_notification_values(client, live_server):
     
 
     if os.path.isfile("test-datastore/notification.txt"):
@@ -383,10 +388,11 @@ def test_change_with_notification_values(client, live_server, measure_memory_usa
     assert os.path.isfile("test-datastore/notification.txt"), "Notification received"
 
 
-def test_data_sanity(client, live_server, measure_memory_usage):
+def test_data_sanity(client, live_server):
     
 
-    delete_all_watches(client)
+    res = client.get(url_for("ui.form_delete", uuid="all"), follow_redirects=True)
+    assert b'Deleted' in res.data
 
     test_url = url_for('test_endpoint', _external=True)
     test_url2 = url_for('test_endpoint2', _external=True)
@@ -413,7 +419,8 @@ def test_data_sanity(client, live_server, measure_memory_usage):
     assert str(res.data.decode()).count("950.95") == 1, "Price should only show once (for the watch added, no other watches yet)"
 
     ## different test, check the edit page works on an empty request result
-    delete_all_watches(client)
+    res = client.get(url_for("ui.form_delete", uuid="all"), follow_redirects=True)
+    assert b'Deleted' in res.data
 
     client.post(
         url_for("ui.ui_views.form_quick_watch_add"),
@@ -426,10 +433,11 @@ def test_data_sanity(client, live_server, measure_memory_usage):
         url_for("ui.ui_edit.edit_page", uuid="first"))
     assert test_url2.encode('utf-8') in res.data
 
-    delete_all_watches(client)
+    res = client.get(url_for("ui.form_delete", uuid="all"), follow_redirects=True)
+    assert b'Deleted' in res.data
 
 # All examples should give a prive of 666.66
-def test_special_prop_examples(client, live_server, measure_memory_usage):
+def test_special_prop_examples(client, live_server):
     import glob
     
 

changedetectionio/tests/test_rss.py

@@ -3,7 +3,7 @@
 import time
 from flask import url_for
 from .util import set_original_response, set_modified_response, live_server_setup, wait_for_all_checks, extract_rss_token_from_UI, \
-    extract_UUID_from_client, delete_all_watches
+    extract_UUID_from_client
 
 
 def set_original_cdata_xml():
@@ -111,11 +111,16 @@ def test_basic_cdata_rss_markup(client, live_server, measure_memory_usage):
 
     set_original_cdata_xml()
 
-    test_url = url_for('test_endpoint', content_type="application/atom+xml; charset=UTF-8", _external=True)
+    test_url = url_for('test_endpoint', content_type="application/xml", _external=True)
 
     # Add our URL to the import page
-    uuid = client.application.config.get('DATASTORE').add_watch(url=test_url)
-    client.get(url_for("ui.form_watch_checknow"), follow_redirects=True)
+    res = client.post(
+        url_for("imports.import_page"),
+        data={"urls": test_url},
+        follow_redirects=True
+    )
+
+    assert b"1 Imported" in res.data
 
     wait_for_all_checks(client)
 
@@ -127,14 +132,14 @@ def test_basic_cdata_rss_markup(client, live_server, measure_memory_usage):
     assert b'<![' not in res.data
     assert b'Hackers can access your computer' in res.data
     assert b'The days of Terminator' in res.data
-    delete_all_watches(client)
+    res = client.get(url_for("ui.form_delete", uuid="all"), follow_redirects=True)
 
 def test_rss_xpath_filtering(client, live_server, measure_memory_usage):
     
 
     set_original_cdata_xml()
 
-    test_url = url_for('test_endpoint', content_type="application/atom+xml; charset=UTF-8", _external=True)
+    test_url = url_for('test_endpoint', content_type="application/xml", _external=True)
 
     res = client.post(
         url_for("ui.ui_views.form_quick_watch_add"),
@@ -153,7 +158,6 @@ def test_rss_xpath_filtering(client, live_server, measure_memory_usage):
                 "proxy": "no-proxy",
                 "tags": "",
                 "url": test_url,
-                "time_between_check_use_default": "y",
               },
         follow_redirects=True
     )
@@ -175,10 +179,10 @@ def test_rss_xpath_filtering(client, live_server, measure_memory_usage):
     assert b'The days of Terminator' not in res.data # Should NOT be selected by the xpath
     assert b'Some other description' not in res.data  # Should NOT be selected by the xpath
 
-    delete_all_watches(client)
+    res = client.get(url_for("ui.form_delete", uuid="all"), follow_redirects=True)
 
 
-def test_rss_bad_chars_breaking(client, live_server, measure_memory_usage):
+def test_rss_bad_chars_breaking(client, live_server):
     """This should absolutely trigger the RSS builder to go into worst state mode
 
     - source: prefix means no html conversion (which kinda filters out the bad stuff)

changedetectionio/tests/test_scheduler.py

@@ -1,15 +1,12 @@
 #!/usr/bin/env python3
 
 import time
-from copy import copy
 from datetime import datetime, timezone
 from zoneinfo import ZoneInfo
 from flask import url_for
-from .util import  live_server_setup, wait_for_all_checks, extract_UUID_from_client, delete_all_watches
-from ..forms import REQUIRE_ATLEAST_ONE_TIME_PART_MESSAGE_DEFAULT, REQUIRE_ATLEAST_ONE_TIME_PART_WHEN_NOT_GLOBAL_DEFAULT
+from .util import  live_server_setup, wait_for_all_checks, extract_UUID_from_client
 
-
-# def test_setup(client, live_server, measure_memory_usage):
+# def test_setup(client, live_server):
    #  live_server_setup(live_server) # Setup on conftest per function
 
 def test_check_basic_scheduler_functionality(client, live_server, measure_memory_usage):
@@ -34,18 +31,22 @@ def test_check_basic_scheduler_functionality(client, live_server, measure_memory
     res = client.get(url_for("settings.settings_page"))
     assert b'Pacific/Kiritimati' in res.data
 
-    uuid = client.application.config.get('DATASTORE').add_watch(url=test_url)
-    client.get(url_for("ui.form_watch_checknow"), follow_redirects=True)
+    res = client.post(
+        url_for("imports.import_page"),
+        data={"urls": test_url},
+        follow_redirects=True
+    )
+
+    assert b"1 Imported" in res.data
     wait_for_all_checks(client)
     uuid = next(iter(live_server.app.config['DATASTORE'].data['watching']))
 
     # Setup all the days of the weeks using XXX as the placeholder for monday/tuesday/etc
-    last_check = copy(live_server.app.config['DATASTORE'].data['watching'][uuid]['last_checked'])
+
     tpl = {
         "time_schedule_limit-XXX-start_time": "00:00",
         "time_schedule_limit-XXX-duration-hours": 24,
         "time_schedule_limit-XXX-duration-minutes": 0,
-        "time_between_check-seconds": 1,
         "time_schedule_limit-XXX-enabled": '',  # All days are turned off
         "time_schedule_limit-enabled": 'y',  # Scheduler is enabled, all days however are off.
     }
@@ -57,13 +58,13 @@ def test_check_basic_scheduler_functionality(client, live_server, measure_memory
             new_key = key.replace("XXX", day)
             scheduler_data[new_key] = value
 
+    last_check = live_server.app.config['DATASTORE'].data['watching'][uuid]['last_checked']
     data = {
         "url": test_url,
-        "fetch_backend": "html_requests",
-        "time_between_check_use_default": "" # no
+        "fetch_backend": "html_requests"
     }
     data.update(scheduler_data)
-    time.sleep(1)
+
     res = client.post(
         url_for("ui.ui_edit.edit_page", uuid="first"),
         data=data,
@@ -76,7 +77,6 @@ def test_check_basic_scheduler_functionality(client, live_server, measure_memory
 
     # "Edit" should not trigger a check because it's not enabled in the schedule.
     time.sleep(2)
-    # "time_schedule_limit-XXX-enabled": '',  # All days are turned off, therefor, nothing should happen here..
     assert live_server.app.config['DATASTORE'].data['watching'][uuid]['last_checked'] == last_check
 
     # Enabling today in Kiritimati should work flawless
@@ -87,7 +87,8 @@ def test_check_basic_scheduler_functionality(client, live_server, measure_memory
     assert live_server.app.config['DATASTORE'].data['watching'][uuid]['last_checked'] != last_check
 
     # Cleanup everything
-    delete_all_watches(client)
+    res = client.get(url_for("ui.form_delete", uuid="all"), follow_redirects=True)
+    assert b'Deleted' in res.data
 
 
 def test_check_basic_global_scheduler_functionality(client, live_server, measure_memory_usage):
@@ -95,8 +96,13 @@ def test_check_basic_global_scheduler_functionality(client, live_server, measure
     days = ['monday', 'tuesday', 'wednesday', 'thursday', 'friday', 'saturday', 'sunday']
     test_url = url_for('test_random_content_endpoint', _external=True)
 
-    uuid = client.application.config.get('DATASTORE').add_watch(url=test_url)
-    client.get(url_for("ui.form_watch_checknow"), follow_redirects=True)
+    res = client.post(
+        url_for("imports.import_page"),
+        data={"urls": test_url},
+        follow_redirects=True
+    )
+
+    assert b"1 Imported" in res.data
     wait_for_all_checks(client)
     uuid = next(iter(live_server.app.config['DATASTORE'].data['watching']))
 
@@ -169,41 +175,5 @@ def test_check_basic_global_scheduler_functionality(client, live_server, measure
     assert live_server.app.config['DATASTORE'].data['watching'][uuid]['last_checked'] != last_check
 
     # Cleanup everything
-    delete_all_watches(client)
-
-
-def test_validation_time_interval_field(client, live_server, measure_memory_usage):
-    test_url = url_for('test_endpoint', _external=True)
-    uuid = client.application.config.get('DATASTORE').add_watch(url=test_url)
-    client.get(url_for("ui.form_watch_checknow"), follow_redirects=True)
-
-
-    res = client.post(
-        url_for("ui.ui_edit.edit_page", uuid="first"),
-        data={"trigger_text": 'The golden line',
-              "url": test_url,
-              'fetch_backend': "html_requests",
-              'filter_text_removed': 'y',
-              "time_between_check_use_default": ""
-              },
-        follow_redirects=True
-    )
-
-    assert REQUIRE_ATLEAST_ONE_TIME_PART_WHEN_NOT_GLOBAL_DEFAULT.encode('utf-8') in res.data
-
-    # Now set atleast something
-
-    res = client.post(
-        url_for("ui.ui_edit.edit_page", uuid="first"),
-        data={"trigger_text": 'The golden line',
-              "url": test_url,
-              'fetch_backend': "html_requests",
-              "time_between_check-minutes": 1,
-              "time_between_check_use_default": ""
-              },
-        follow_redirects=True
-    )
-
-    assert REQUIRE_ATLEAST_ONE_TIME_PART_WHEN_NOT_GLOBAL_DEFAULT.encode('utf-8') not in res.data
-
-
+    res = client.get(url_for("ui.form_delete", uuid="all"), follow_redirects=True)
+    assert b'Deleted' in res.data

changedetectionio/tests/test_search.py

@@ -27,7 +27,7 @@ def test_basic_search(client, live_server, measure_memory_usage):
 
     res = client.post(
         url_for("ui.ui_edit.edit_page", uuid="first"),
-        data={"title": "xxx-title", "url": urls[0], "tags": "", "headers": "", 'fetch_backend': "html_requests", "time_between_check_use_default": "y"},
+        data={"title": "xxx-title", "url": urls[0], "tags": "", "headers": "", 'fetch_backend': "html_requests"},
         follow_redirects=True
     )
     assert b"Updated watch." in res.data
@@ -62,7 +62,7 @@ def test_search_in_tag_limit(client, live_server, measure_memory_usage):
     res = client.post(
         url_for("ui.ui_edit.edit_page", uuid="first"),
         data={"title": "xxx-title", "url": urls[0].split(' ')[0], "tags": urls[0].split(' ')[1], "headers": "",
-              'fetch_backend': "html_requests", "time_between_check_use_default": "y"},
+              'fetch_backend': "html_requests"},
         follow_redirects=True
     )
     assert b"Updated watch." in res.data

changedetectionio/tests/test_security.py

@@ -1,7 +1,7 @@
 import os
 
 from flask import url_for
-from .util import live_server_setup, wait_for_all_checks, delete_all_watches
+from .util import live_server_setup, wait_for_all_checks
 from .. import strtobool
 
 
@@ -41,8 +41,7 @@ def test_bad_access(client, live_server, measure_memory_usage):
               "tags": "",
               "method": "GET",
               "fetch_backend": "html_requests",
-              "body": "",
-              "time_between_check_use_default": "y"},
+              "body": ""},
         follow_redirects=True
     )
 
@@ -100,7 +99,8 @@ def _runner_test_various_file_slash(client, file_uri):
             # This will give some error from requests or if it went to chrome, will give some other error :-)
             assert any(s in res.data for s in substrings)
 
-    delete_all_watches(client)
+    res = client.get(url_for("ui.form_delete", uuid="all"), follow_redirects=True)
+    assert b'Deleted' in res.data
 
 def test_file_slash_access(client, live_server, measure_memory_usage):
     
@@ -150,8 +150,7 @@ def test_xss_watch_last_error(client, live_server, measure_memory_usage):
         data={
             "include_filters": '<a href="https://foobar"></a><script>alert(123);</script>',
             "url": url_for('test_endpoint', _external=True),
-            'fetch_backend': "html_requests",
-            "time_between_check_use_default": "y"
+            'fetch_backend': "html_requests"
         },
         follow_redirects=True
     )

changedetectionio/tests/test_share_watch.py

@@ -3,7 +3,7 @@
 import time
 from flask import url_for
 from urllib.request import urlopen
-from .util import set_original_response, set_modified_response, live_server_setup, delete_all_watches
+from .util import set_original_response, set_modified_response, live_server_setup
 import re
 
 sleep_time_for_fetch_thread = 3
@@ -17,14 +17,19 @@ def test_share_watch(client, live_server, measure_memory_usage):
     include_filters = ".nice-filter"
 
     # Add our URL to the import page
-    uuid = client.application.config.get('DATASTORE').add_watch(url=test_url)
-    client.get(url_for("ui.form_watch_checknow"), follow_redirects=True)
+    res = client.post(
+        url_for("imports.import_page"),
+        data={"urls": test_url},
+        follow_redirects=True
+    )
+
+    assert b"1 Imported" in res.data
 
     # Goto the edit page, add our ignore text
     # Add our URL to the import page
     res = client.post(
         url_for("ui.ui_edit.edit_page", uuid="first"),
-        data={"include_filters": include_filters, "url": test_url, "tags": "", "headers": "", 'fetch_backend': "html_requests", "time_between_check_use_default": "y"},
+        data={"include_filters": include_filters, "url": test_url, "tags": "", "headers": "", 'fetch_backend': "html_requests"},
         follow_redirects=True
     )
     assert b"Updated watch." in res.data
@@ -49,7 +54,8 @@ def test_share_watch(client, live_server, measure_memory_usage):
 
     # Now delete what we have, we will try to re-import it
     # Cleanup everything
-    delete_all_watches(client)
+    res = client.get(url_for("ui.form_delete", uuid="all"), follow_redirects=True)
+    assert b'Deleted' in res.data
 
     # Add our URL to the import page
     res = client.post(

changedetectionio/tests/test_source.py

@@ -13,8 +13,13 @@ def test_check_basic_change_detection_functionality_source(client, live_server,
     set_original_response()
     test_url = 'source:'+url_for('test_endpoint', _external=True)
     # Add our URL to the import page
-    uuid = client.application.config.get('DATASTORE').add_watch(url=test_url)
-    client.get(url_for("ui.form_watch_checknow"), follow_redirects=True)
+    res = client.post(
+        url_for("imports.import_page"),
+        data={"urls": test_url},
+        follow_redirects=True
+    )
+
+    assert b"1 Imported" in res.data
 
     time.sleep(sleep_time_for_fetch_thread)
 
@@ -38,9 +43,9 @@ def test_check_basic_change_detection_functionality_source(client, live_server,
 
     wait_for_all_checks(client)
 
-    # Now something should be ready, indicated by having a 'has-unread-changes' class
+    # Now something should be ready, indicated by having a 'unviewed' class
     res = client.get(url_for("watchlist.index"))
-    assert b'has-unread-changes' in res.data
+    assert b'unviewed' in res.data
 
     res = client.get(
         url_for("ui.ui_views.diff_history_page", uuid="first"),
@@ -57,8 +62,13 @@ def test_check_ignore_elements(client, live_server, measure_memory_usage):
     time.sleep(1)
     test_url = 'source:'+url_for('test_endpoint', _external=True)
     # Add our URL to the import page
-    uuid = client.application.config.get('DATASTORE').add_watch(url=test_url)
-    client.get(url_for("ui.form_watch_checknow"), follow_redirects=True)
+    res = client.post(
+        url_for("imports.import_page"),
+        data={"urls": test_url},
+        follow_redirects=True
+    )
+
+    assert b"1 Imported" in res.data
 
     wait_for_all_checks(client)
 
@@ -67,7 +77,7 @@ def test_check_ignore_elements(client, live_server, measure_memory_usage):
 
     client.post(
         url_for("ui.ui_edit.edit_page", uuid="first"),
-        data={"include_filters": 'span,p', "url": test_url, "tags": "", "subtractive_selectors": ".foobar-detection", 'fetch_backend': "html_requests", "time_between_check_use_default": "y"},
+        data={"include_filters": 'span,p', "url": test_url, "tags": "", "subtractive_selectors": ".foobar-detection", 'fetch_backend': "html_requests"},
         follow_redirects=True
     )
 

changedetectionio/tests/test_trigger.py

@@ -65,8 +65,12 @@ def test_trigger_functionality(client, live_server, measure_memory_usage):
 
     # Add our URL to the import page
     test_url = url_for('test_endpoint', _external=True)
-    uuid = client.application.config.get('DATASTORE').add_watch(url=test_url)
-    client.get(url_for("ui.form_watch_checknow"), follow_redirects=True)
+    res = client.post(
+        url_for("imports.import_page"),
+        data={"urls": test_url},
+        follow_redirects=True
+    )
+    assert b"1 Imported" in res.data
 
     # Trigger a check
     client.get(url_for("ui.form_watch_checknow"), follow_redirects=True)
@@ -77,8 +81,7 @@ def test_trigger_functionality(client, live_server, measure_memory_usage):
         url_for("ui.ui_edit.edit_page", uuid="first"),
         data={"trigger_text": trigger_text,
               "url": test_url,
-              "fetch_backend": "html_requests",
-              "time_between_check_use_default": "y"},
+              "fetch_backend": "html_requests"},
         follow_redirects=True
     )
     assert b"Updated watch." in res.data
@@ -92,7 +95,7 @@ def test_trigger_functionality(client, live_server, measure_memory_usage):
 
 
     
-    # so that we set the state to 'has-unread-changes' after all the edits
+    # so that we set the state to 'unviewed' after all the edits
     client.get(url_for("ui.ui_views.diff_history_page", uuid="first"))
 
     # Trigger a check
@@ -100,9 +103,9 @@ def test_trigger_functionality(client, live_server, measure_memory_usage):
 
     wait_for_all_checks(client)
 
-    # It should report nothing found (no new 'has-unread-changes' class)
+    # It should report nothing found (no new 'unviewed' class)
     res = client.get(url_for("watchlist.index"))
-    assert b'has-unread-changes' not in res.data
+    assert b'unviewed' not in res.data
     assert b'/test-endpoint' in res.data
 
     #  Make a change
@@ -112,9 +115,9 @@ def test_trigger_functionality(client, live_server, measure_memory_usage):
     client.get(url_for("ui.form_watch_checknow"), follow_redirects=True)
     wait_for_all_checks(client)
 
-    # It should report nothing found (no new 'has-unread-changes' class)
+    # It should report nothing found (no new 'unviewed' class)
     res = client.get(url_for("watchlist.index"))
-    assert b'has-unread-changes' not in res.data
+    assert b'unviewed' not in res.data
 
     # Now set the content which contains the trigger text
     set_modified_with_trigger_text_response()
@@ -122,7 +125,7 @@ def test_trigger_functionality(client, live_server, measure_memory_usage):
     client.get(url_for("ui.form_watch_checknow"), follow_redirects=True)
     wait_for_all_checks(client)
     res = client.get(url_for("watchlist.index"))
-    assert b'has-unread-changes' in res.data
+    assert b'unviewed' in res.data
     
     # https://github.com/dgtlmoon/changedetection.io/issues/616
     # Apparently the actual snapshot that contains the trigger never shows

changedetectionio/tests/test_trigger_regex.py

@@ -2,7 +2,7 @@
 
 import time
 from flask import url_for
-from .util import live_server_setup, wait_for_all_checks, delete_all_watches
+from .util import live_server_setup, wait_for_all_checks
 
 
 def set_original_ignore_response():
@@ -30,27 +30,30 @@ def test_trigger_regex_functionality(client, live_server, measure_memory_usage):
 
     # Add our URL to the import page
     test_url = url_for('test_endpoint', _external=True)
-    uuid = client.application.config.get('DATASTORE').add_watch(url=test_url)
-    client.get(url_for("ui.form_watch_checknow"), follow_redirects=True)
+    res = client.post(
+        url_for("imports.import_page"),
+        data={"urls": test_url},
+        follow_redirects=True
+    )
+    assert b"1 Imported" in res.data
 
     # Give the thread time to pick it up
     wait_for_all_checks(client)
 
     # It should report nothing found (just a new one shouldnt have anything)
     res = client.get(url_for("watchlist.index"))
-    assert b'has-unread-changes' not in res.data
+    assert b'unviewed' not in res.data
 
     ### test regex
     res = client.post(
         url_for("ui.ui_edit.edit_page", uuid="first"),
         data={"trigger_text": '/something \d{3}/',
               "url": test_url,
-              "fetch_backend": "html_requests",
-              "time_between_check_use_default": "y"},
+              "fetch_backend": "html_requests"},
         follow_redirects=True
     )
     wait_for_all_checks(client)
-    # so that we set the state to 'has-unread-changes' after all the edits
+    # so that we set the state to 'unviewed' after all the edits
     client.get(url_for("ui.ui_views.diff_history_page", uuid="first"))
 
     with open("test-datastore/endpoint-content.txt", "w") as f:
@@ -61,7 +64,7 @@ def test_trigger_regex_functionality(client, live_server, measure_memory_usage):
 
     # It should report nothing found (nothing should match the regex)
     res = client.get(url_for("watchlist.index"))
-    assert b'has-unread-changes' not in res.data
+    assert b'unviewed' not in res.data
 
     with open("test-datastore/endpoint-content.txt", "w") as f:
         f.write("regex test123<br>\nsomething 123")
@@ -69,7 +72,8 @@ def test_trigger_regex_functionality(client, live_server, measure_memory_usage):
     client.get(url_for("ui.form_watch_checknow"), follow_redirects=True)
     wait_for_all_checks(client)
     res = client.get(url_for("watchlist.index"))
-    assert b'has-unread-changes' in res.data
+    assert b'unviewed' in res.data
 
     # Cleanup everything
-    delete_all_watches(client)
+    res = client.get(url_for("ui.form_delete", uuid="all"), follow_redirects=True)
+    assert b'Deleted' in res.data

changedetectionio/tests/test_trigger_regex_with_filter.py

@@ -2,7 +2,7 @@
 
 import time
 from flask import url_for
-from . util import live_server_setup, delete_all_watches
+from . util import live_server_setup
 
 
 def set_original_ignore_response():
@@ -34,8 +34,12 @@ def test_trigger_regex_functionality_with_filter(client, live_server, measure_me
 
     # Add our URL to the import page
     test_url = url_for('test_endpoint', _external=True)
-    uuid = client.application.config.get('DATASTORE').add_watch(url=test_url)
-    client.get(url_for("ui.form_watch_checknow"), follow_redirects=True)
+    res = client.post(
+        url_for("imports.import_page"),
+        data={"urls": test_url},
+        follow_redirects=True
+    )
+    assert b"1 Imported" in res.data
 
     # it needs time to save the original version
     time.sleep(sleep_time_for_fetch_thread)
@@ -46,8 +50,7 @@ def test_trigger_regex_functionality_with_filter(client, live_server, measure_me
         data={"trigger_text": "/cool.stuff/",
               "url": test_url,
               "include_filters": '#in-here',
-              "fetch_backend": "html_requests",
-              "time_between_check_use_default": "y"},
+              "fetch_backend": "html_requests"},
         follow_redirects=True
     )
 
@@ -65,7 +68,7 @@ def test_trigger_regex_functionality_with_filter(client, live_server, measure_me
 
     # It should report nothing found (nothing should match the regex and filter)
     res = client.get(url_for("watchlist.index"))
-    assert b'has-unread-changes' not in res.data
+    assert b'unviewed' not in res.data
 
     # now this should trigger something
     with open("test-datastore/endpoint-content.txt", "w") as f:
@@ -74,7 +77,8 @@ def test_trigger_regex_functionality_with_filter(client, live_server, measure_me
     client.get(url_for("ui.form_watch_checknow"), follow_redirects=True)
     time.sleep(sleep_time_for_fetch_thread)
     res = client.get(url_for("watchlist.index"))
-    assert b'has-unread-changes' in res.data
+    assert b'unviewed' in res.data
 
 # Cleanup everything
-    delete_all_watches(client)
+    res = client.get(url_for("ui.form_delete", uuid="all"), follow_redirects=True)
+    assert b'Deleted' in res.data

changedetectionio/tests/test_ui.py

@@ -1,103 +1,13 @@
 #!/usr/bin/env python3
 
 from flask import url_for
-from .util import set_original_response, set_modified_response, live_server_setup, wait_for_all_checks, delete_all_watches
-from ..forms import REQUIRE_ATLEAST_ONE_TIME_PART_WHEN_NOT_GLOBAL_DEFAULT, REQUIRE_ATLEAST_ONE_TIME_PART_MESSAGE_DEFAULT
+from .util import set_original_response, set_modified_response, live_server_setup, wait_for_all_checks
 
-
-def test_recheck_time_field_validation_global_settings(client, live_server, measure_memory_usage):
-    """
-    Tests that the global settings time field has atleast one value for week/day/hours/minute/seconds etc entered
-    class globalSettingsRequestForm(Form):
-        time_between_check = RequiredFormField(TimeBetweenCheckForm)
-    """
-    res = client.post(
-        url_for("settings.settings_page"),
-        data={
-              "requests-time_between_check-weeks": '',
-              "requests-time_between_check-days": '',
-              "requests-time_between_check-hours": '',
-              "requests-time_between_check-minutes": '',
-              "requests-time_between_check-seconds": '',
-              },
-        follow_redirects=True
-    )
-
-
-    assert REQUIRE_ATLEAST_ONE_TIME_PART_MESSAGE_DEFAULT.encode('utf-8') in res.data
-
-
-def test_recheck_time_field_validation_single_watch(client, live_server, measure_memory_usage):
-    """
-    Tests that the global settings time field has atleast one value for week/day/hours/minute/seconds etc entered
-    class globalSettingsRequestForm(Form):
-        time_between_check = RequiredFormField(TimeBetweenCheckForm)
-    """
-    test_url = url_for('test_endpoint', _external=True)
-
-    # Add our URL to the import page
-    uuid = client.application.config.get('DATASTORE').add_watch(url=test_url)
-    client.get(url_for("ui.form_watch_checknow"), follow_redirects=True)
-
-    res = client.post(
-        url_for("ui.ui_edit.edit_page", uuid="first"),
-        data={
-            "url": test_url,
-            'fetch_backend': "html_requests",
-            "time_between_check_use_default": "",  # OFF
-            "time_between_check-weeks": '',
-            "time_between_check-days": '',
-            "time_between_check-hours": '',
-            "time_between_check-minutes": '',
-            "time_between_check-seconds": '',
-        },
-        follow_redirects=True
-    )
-
-
-    assert REQUIRE_ATLEAST_ONE_TIME_PART_WHEN_NOT_GLOBAL_DEFAULT.encode('utf-8') in res.data
-
-    # Now set some time
-    res = client.post(
-        url_for("ui.ui_edit.edit_page", uuid="first"),
-        data={
-            "url": test_url,
-            'fetch_backend': "html_requests",
-            "time_between_check_use_default": "",  # OFF
-            "time_between_check-weeks": '',
-            "time_between_check-days": '',
-            "time_between_check-hours": '',
-            "time_between_check-minutes": '5',
-            "time_between_check-seconds": '',
-        },
-        follow_redirects=True
-    )
-
-    assert b"Updated watch." in res.data
-    assert REQUIRE_ATLEAST_ONE_TIME_PART_WHEN_NOT_GLOBAL_DEFAULT.encode('utf-8') not in res.data
-
-    # Now set to use defaults
-    res = client.post(
-        url_for("ui.ui_edit.edit_page", uuid="first"),
-        data={
-            "url": test_url,
-            'fetch_backend': "html_requests",
-            "time_between_check_use_default": "y",  # ON YES
-            "time_between_check-weeks": '',
-            "time_between_check-days": '',
-            "time_between_check-hours": '',
-            "time_between_check-minutes": '',
-            "time_between_check-seconds": '',
-        },
-        follow_redirects=True
-    )
-
-    assert b"Updated watch." in res.data
-    assert REQUIRE_ATLEAST_ONE_TIME_PART_WHEN_NOT_GLOBAL_DEFAULT.encode('utf-8') not in res.data
-
-def test_checkbox_open_diff_in_new_tab(client, live_server, measure_memory_usage):
+def test_checkbox_open_diff_in_new_tab(client, live_server):
     
     set_original_response()
+   #  live_server_setup(live_server) # Setup on conftest per function
+
     # Add our URL to the import page
     res = client.post(
         url_for("imports.import_page"),
@@ -166,120 +76,5 @@ def test_checkbox_open_diff_in_new_tab(client, live_server, measure_memory_usage
     assert 'target=' not in target_line
 
     # Cleanup everything
-    delete_all_watches(client)
-
-def test_page_title_listing_behaviour(client, live_server, measure_memory_usage):
-
-    set_original_response(extra_title="custom html")
-
-    # either the manually entered title/description or the page link should be visible
-    res = client.post(
-        url_for("settings.settings_page"),
-        data={"application-ui-use_page_title_in_list": "",
-              "requests-time_between_check-minutes": 180,
-              'application-fetch_backend': "html_requests"},
-        follow_redirects=True
-    )
-    assert b"Settings updated." in res.data
-
-
-    # Add our URL to the import page
-    res = client.post(
-        url_for("imports.import_page"),
-        data={"urls": url_for('test_endpoint', _external=True)},
-        follow_redirects=True
-    )
-
-    assert b"1 Imported" in res.data
-    wait_for_all_checks(client)
-
-    # We see the URL only, no title/description was manually entered
-    res = client.get(url_for("watchlist.index"))
-    assert url_for('test_endpoint', _external=True).encode('utf-8') in res.data
-
-
-    # Now 'my title' should override
-    res = client.post(
-        url_for("ui.ui_edit.edit_page", uuid="first"),
-        data={
-        "url": url_for('test_endpoint', _external=True),
-        "title": "my title",
-        "fetch_backend": "html_requests",
-        "time_between_check_use_default": "y"},
-        follow_redirects=True
-    )
-    assert b"Updated watch." in res.data
-    res = client.get(url_for("watchlist.index"))
-    assert b"my title" in res.data
-
-    # Now we enable page <title> and unset the override title/description
-    res = client.post(
-        url_for("settings.settings_page"),
-        data={"application-ui-use_page_title_in_list": "y",
-              "requests-time_between_check-minutes": 180,
-              'application-fetch_backend': "html_requests"},
-        follow_redirects=True
-    )
-    assert b"Settings updated." in res.data
-
-    # Page title description override should take precedence
-    res = client.get(url_for("watchlist.index"))
-    assert b"my title" in res.data
-
-    # Remove page title description override and it should fall back to title
-    res = client.post(
-        url_for("ui.ui_edit.edit_page", uuid="first"),
-        data={
-        "url": url_for('test_endpoint', _external=True),
-        "title": "",
-        "fetch_backend": "html_requests",
-        "time_between_check_use_default": "y"},
-        follow_redirects=True
-    )
-    assert b"Updated watch." in res.data
-
-    # No page title description, and 'use_page_title_in_list' is on, it should show the <title>
-    res = client.get(url_for("watchlist.index"))
-    assert b"head titlecustom html" in res.data
-
-
-def test_ui_viewed_unread_flag(client, live_server, measure_memory_usage):
-
-    import time
-
-    set_original_response(extra_title="custom html")
-
-    # Add our URL to the import page
-    res = client.post(
-        url_for("imports.import_page"),
-        data={"urls": url_for('test_endpoint', _external=True)+"\r\n"+url_for('test_endpoint', _external=True)},
-        follow_redirects=True
-    )
-
-    assert b"2 Imported" in res.data
-    wait_for_all_checks(client)
-
-    set_modified_response()
-    res = client.get(url_for("ui.form_watch_checknow"), follow_redirects=True)
-    assert b'Queued 2 watches for rechecking.' in res.data
-    wait_for_all_checks(client)
-    res = client.get(url_for("watchlist.index"))
-    assert b'<span id="unread-tab-counter">2</span>' in res.data
-    assert res.data.count(b'data-watch-uuid') == 2
-
-    # one should now be viewed, but two in total still
-    client.get(url_for("ui.ui_views.diff_history_page", uuid="first"))
-    res = client.get(url_for("watchlist.index"))
-    assert b'<span id="unread-tab-counter">1</span>' in res.data
-    assert res.data.count(b'data-watch-uuid') == 2
-
-    # check ?unread=1 works
-    res = client.get(url_for("watchlist.index")+"?unread=1")
-    assert res.data.count(b'data-watch-uuid') == 1
-    assert b'<span id="unread-tab-counter">1</span>' in res.data
-
-    # Mark all viewed test again
-    client.get(url_for("ui.mark_all_viewed"), follow_redirects=True)
-    time.sleep(0.2)
-    res = client.get(url_for("watchlist.index"))
-    assert b'<span id="unread-tab-counter">0</span>' in res.data
+    res = client.get(url_for("ui.form_delete", uuid="all"), follow_redirects=True)
+    assert b'Deleted' in res.data

changedetectionio/tests/test_unique_lines.py

@@ -2,7 +2,7 @@
 
 import time
 from flask import url_for
-from .util import live_server_setup, wait_for_all_checks, delete_all_watches
+from .util import live_server_setup, wait_for_all_checks
 
 
 def set_original_ignore_response():
@@ -79,8 +79,12 @@ def test_unique_lines_functionality(client, live_server, measure_memory_usage):
 
     # Add our URL to the import page
     test_url = url_for('test_endpoint', _external=True)
-    uuid = client.application.config.get('DATASTORE').add_watch(url=test_url)
-    client.get(url_for("ui.form_watch_checknow"), follow_redirects=True)
+    res = client.post(
+        url_for("imports.import_page"),
+        data={"urls": test_url},
+        follow_redirects=True
+    )
+    assert b"1 Imported" in res.data
     wait_for_all_checks(client)
 
     # Add our URL to the import page
@@ -88,12 +92,11 @@ def test_unique_lines_functionality(client, live_server, measure_memory_usage):
         url_for("ui.ui_edit.edit_page", uuid="first"),
         data={"check_unique_lines": "y",
               "url": test_url,
-              "fetch_backend": "html_requests",
-              "time_between_check_use_default": "y"},
+              "fetch_backend": "html_requests"},
         follow_redirects=True
     )
     assert b"Updated watch." in res.data
-    assert b'has-unread-changes' not in res.data
+    assert b'unviewed' not in res.data
 
     #  Make a change
     set_modified_swapped_lines()
@@ -104,17 +107,18 @@ def test_unique_lines_functionality(client, live_server, measure_memory_usage):
     # Give the thread time to pick it up
     wait_for_all_checks(client)
 
-    # It should report nothing found (no new 'has-unread-changes' class)
+    # It should report nothing found (no new 'unviewed' class)
     res = client.get(url_for("watchlist.index"))
-    assert b'has-unread-changes' not in res.data
+    assert b'unviewed' not in res.data
 
     # Now set the content which contains the new text and re-ordered existing text
     set_modified_with_trigger_text_response()
     client.get(url_for("ui.form_watch_checknow"), follow_redirects=True)
     wait_for_all_checks(client)
     res = client.get(url_for("watchlist.index"))
-    assert b'has-unread-changes' in res.data
-    delete_all_watches(client)
+    assert b'unviewed' in res.data
+    res = client.get(url_for("ui.form_delete", uuid="all"), follow_redirects=True)
+    assert b'Deleted' in res.data
 
 def test_sort_lines_functionality(client, live_server, measure_memory_usage):
     
@@ -123,8 +127,12 @@ def test_sort_lines_functionality(client, live_server, measure_memory_usage):
 
     # Add our URL to the import page
     test_url = url_for('test_endpoint', _external=True)
-    uuid = client.application.config.get('DATASTORE').add_watch(url=test_url)
-    client.get(url_for("ui.form_watch_checknow"), follow_redirects=True)
+    res = client.post(
+        url_for("imports.import_page"),
+        data={"urls": test_url},
+        follow_redirects=True
+    )
+    assert b"1 Imported" in res.data
     wait_for_all_checks(client)
 
     # Add our URL to the import page
@@ -132,8 +140,7 @@ def test_sort_lines_functionality(client, live_server, measure_memory_usage):
         url_for("ui.ui_edit.edit_page", uuid="first"),
         data={"sort_text_alphabetically": "n",
               "url": test_url,
-              "fetch_backend": "html_requests",
-              "time_between_check_use_default": "y"},
+              "fetch_backend": "html_requests"},
         follow_redirects=True
     )
     assert b"Updated watch." in res.data
@@ -148,7 +155,7 @@ def test_sort_lines_functionality(client, live_server, measure_memory_usage):
 
     res = client.get(url_for("watchlist.index"))
     # Should be a change registered
-    assert b'has-unread-changes' in res.data
+    assert b'unviewed' in res.data
 
     res = client.get(
         url_for("ui.ui_views.preview_page", uuid="first"),
@@ -159,7 +166,8 @@ def test_sort_lines_functionality(client, live_server, measure_memory_usage):
     assert res.data.find(b'A uppercase') < res.data.find(b'Z last')
     assert res.data.find(b'Some initial text') < res.data.find(b'Which is across multiple lines')
     
-    delete_all_watches(client)
+    res = client.get(url_for("ui.form_delete", uuid="all"), follow_redirects=True)
+    assert b'Deleted' in res.data
 
 
 def test_extra_filters(client, live_server, measure_memory_usage):
@@ -169,8 +177,12 @@ def test_extra_filters(client, live_server, measure_memory_usage):
 
     # Add our URL to the import page
     test_url = url_for('test_endpoint', _external=True)
-    uuid = client.application.config.get('DATASTORE').add_watch(url=test_url)
-    client.get(url_for("ui.form_watch_checknow"), follow_redirects=True)
+    res = client.post(
+        url_for("imports.import_page"),
+        data={"urls": test_url},
+        follow_redirects=True
+    )
+    assert b"1 Imported" in res.data
     wait_for_all_checks(client)
 
     # Add our URL to the import page
@@ -180,8 +192,7 @@ def test_extra_filters(client, live_server, measure_memory_usage):
               "trim_text_whitespace": "y",
               "sort_text_alphabetically": "",  # leave this OFF for testing
               "url": test_url,
-              "fetch_backend": "html_requests",
-              "time_between_check_use_default": "y"},
+              "fetch_backend": "html_requests"},
         follow_redirects=True
     )
     assert b"Updated watch." in res.data
@@ -202,4 +213,5 @@ def test_extra_filters(client, live_server, measure_memory_usage):
     # still should remain unsorted ('A - sortable line') stays at the end
     assert res.data.find(b'A - sortable line') > res.data.find(b'Which is across multiple lines')
 
-    delete_all_watches(client)
+    res = client.get(url_for("ui.form_delete", uuid="all"), follow_redirects=True)
+    assert b'Deleted' in res.data

changedetectionio/tests/test_watch_fields_storage.py

@@ -10,8 +10,12 @@ def test_check_watch_field_storage(client, live_server, measure_memory_usage):
 
     test_url = "http://somerandomsitewewatch.com"
 
-    uuid = client.application.config.get('DATASTORE').add_watch(url=test_url)
-    client.get(url_for("ui.form_watch_checknow"), follow_redirects=True)
+    res = client.post(
+        url_for("imports.import_page"),
+        data={"urls": test_url},
+        follow_redirects=True
+    )
+    assert b"1 Imported" in res.data
 
 
     res = client.post(
@@ -24,8 +28,7 @@ def test_check_watch_field_storage(client, live_server, measure_memory_usage):
                "url": test_url,
                "tags": "woohoo",
                "headers": "curl:foo",
-               'fetch_backend': "html_requests",
-               "time_between_check_use_default": "y"
+               'fetch_backend': "html_requests"
                },
         follow_redirects=True
     )

changedetectionio/tests/test_xpath_selector.py

@@ -1,42 +1,12 @@
 # -*- coding: utf-8 -*-
 
-
+import time
 from flask import url_for
-from .util import  wait_for_all_checks, delete_all_watches
-from ..processors.magic import RSS_XML_CONTENT_TYPES
+from .util import live_server_setup, wait_for_all_checks
+
+from ..html_tools import *
 
 
-def set_rss_atom_feed_response(header=''):
-    test_return_data = f"""{header}<!-- Generated on Wed, 08 Oct 2025 08:42:33 -0700, really really honestly  -->
-<rss xmlns:atom="http://www.w3.org/2005/Atom" version="2.0">
-<channel>
-    <atom:link href="https://store.waterpowered.com/news/collection//" rel="self" type="application/rss+xml"/>
-    <title>RSS Feed</title>
-    <link>
-        <![CDATA[ https://store.waterpowered.com/news/collection// ]]>
-    </link>
-    <description>
-        <![CDATA[ Events and Announcements for ]]>
-    </description>
-    <language>en-us</language>
-    <generator>water News RSS</generator>
-    <item>
-        <title> 🍁 Lets go discount</title>
-        <description><p class="bb_paragraph">ok heres the description</p></description>
-        <link>
-        <![CDATA[ https://store.waterpowered.com/news/app/1643320/view/511845698831908921 ]]>
-        </link>
-        <pubDate>Wed, 08 Oct 2025 15:28:55 +0000</pubDate>
-        <guid isPermaLink="true">https://store.waterpowered.com/news/app/1643320/view/511845698831908921</guid>
-        <enclosure url="https://clan.fastly.waterstatic.com/images/40721482/42822e5f00b2becf520ace9500981bb56f3a89f2.jpg" length="0" type="image/jpeg"/>
-    </item>
-</channel>
-</rss>"""
-
-    with open("test-datastore/endpoint-content.txt", "w") as f:
-        f.write(test_return_data)
-
-    return None
 
 
 
@@ -113,19 +83,24 @@ def test_check_xpath_filter_utf8(client, live_server, measure_memory_usage):
 
     # Add our URL to the import page
     test_url = url_for('test_endpoint', _external=True, content_type="application/rss+xml;charset=UTF-8")
-    uuid = client.application.config.get('DATASTORE').add_watch(url=test_url)
-    client.get(url_for("ui.form_watch_checknow"), follow_redirects=True)
+    res = client.post(
+        url_for("imports.import_page"),
+        data={"urls": test_url},
+        follow_redirects=True
+    )
+    assert b"1 Imported" in res.data
     wait_for_all_checks(client)
     res = client.post(
         url_for("ui.ui_edit.edit_page", uuid="first"),
-        data={"include_filters": filter, "url": test_url, "tags": "", "headers": "", 'fetch_backend': "html_requests", "time_between_check_use_default": "y"},
+        data={"include_filters": filter, "url": test_url, "tags": "", "headers": "", 'fetch_backend': "html_requests"},
         follow_redirects=True
     )
     assert b"Updated watch." in res.data
     wait_for_all_checks(client)
     res = client.get(url_for("watchlist.index"))
     assert b'Unicode strings with encoding declaration are not supported.' not in res.data
-    delete_all_watches(client)
+    res = client.get(url_for("ui.form_delete", uuid="all"), follow_redirects=True)
+    assert b'Deleted' in res.data
 
 
 # Handle utf-8 charset replies https://github.com/dgtlmoon/changedetection.io/pull/613
@@ -162,12 +137,16 @@ def test_check_xpath_text_function_utf8(client, live_server, measure_memory_usag
 
     # Add our URL to the import page
     test_url = url_for('test_endpoint', _external=True, content_type="application/rss+xml;charset=UTF-8")
-    uuid = client.application.config.get('DATASTORE').add_watch(url=test_url)
-    client.get(url_for("ui.form_watch_checknow"), follow_redirects=True)
+    res = client.post(
+        url_for("imports.import_page"),
+        data={"urls": test_url},
+        follow_redirects=True
+    )
+    assert b"1 Imported" in res.data
     wait_for_all_checks(client)
     res = client.post(
         url_for("ui.ui_edit.edit_page", uuid="first"),
-        data={"include_filters": filter, "url": test_url, "tags": "", "headers": "", 'fetch_backend': "html_requests", "time_between_check_use_default": "y"},
+        data={"include_filters": filter, "url": test_url, "tags": "", "headers": "", 'fetch_backend': "html_requests"},
         follow_redirects=True
     )
     assert b"Updated watch." in res.data
@@ -184,7 +163,8 @@ def test_check_xpath_text_function_utf8(client, live_server, measure_memory_usag
     assert b'Stock Alert (UK): RPi CM4' in res.data
     assert b'Stock Alert (UK): Big monitor' in res.data
 
-    delete_all_watches(client)
+    res = client.get(url_for("ui.form_delete", uuid="all"), follow_redirects=True)
+    assert b'Deleted' in res.data
 
 
 def test_check_markup_xpath_filter_restriction(client, live_server, measure_memory_usage):
@@ -194,8 +174,12 @@ def test_check_markup_xpath_filter_restriction(client, live_server, measure_memo
 
     # Add our URL to the import page
     test_url = url_for('test_endpoint', _external=True)
-    uuid = client.application.config.get('DATASTORE').add_watch(url=test_url)
-    client.get(url_for("ui.form_watch_checknow"), follow_redirects=True)
+    res = client.post(
+        url_for("imports.import_page"),
+        data={"urls": test_url},
+        follow_redirects=True
+    )
+    assert b"1 Imported" in res.data
 
     # Give the thread time to pick it up
     wait_for_all_checks(client)
@@ -204,7 +188,7 @@ def test_check_markup_xpath_filter_restriction(client, live_server, measure_memo
     # Add our URL to the import page
     res = client.post(
         url_for("ui.ui_edit.edit_page", uuid="first"),
-        data={"include_filters": xpath_filter, "url": test_url, "tags": "", "headers": "", 'fetch_backend': "html_requests", "time_between_check_use_default": "y"},
+        data={"include_filters": xpath_filter, "url": test_url, "tags": "", "headers": "", 'fetch_backend': "html_requests"},
         follow_redirects=True
     )
     assert b"Updated watch." in res.data
@@ -224,40 +208,51 @@ def test_check_markup_xpath_filter_restriction(client, live_server, measure_memo
     wait_for_all_checks(client)
 
     res = client.get(url_for("watchlist.index"))
-    assert b'has-unread-changes' not in res.data
-    delete_all_watches(client)
+    assert b'unviewed' not in res.data
+    res = client.get(url_for("ui.form_delete", uuid="all"), follow_redirects=True)
+    assert b'Deleted' in res.data
 
 
 def test_xpath_validation(client, live_server, measure_memory_usage):
     # Add our URL to the import page
     test_url = url_for('test_endpoint', _external=True)
-    uuid = client.application.config.get('DATASTORE').add_watch(url=test_url)
-    client.get(url_for("ui.form_watch_checknow"), follow_redirects=True)
+    res = client.post(
+        url_for("imports.import_page"),
+        data={"urls": test_url},
+        follow_redirects=True
+    )
+    assert b"1 Imported" in res.data
     wait_for_all_checks(client)
 
     res = client.post(
         url_for("ui.ui_edit.edit_page", uuid="first"),
-        data={"include_filters": "/something horrible", "url": test_url, "tags": "", "headers": "", 'fetch_backend': "html_requests", "time_between_check_use_default": "y"},
+        data={"include_filters": "/something horrible", "url": test_url, "tags": "", "headers": "", 'fetch_backend': "html_requests"},
         follow_redirects=True
     )
     assert b"is not a valid XPath expression" in res.data
-    delete_all_watches(client)
+    res = client.get(url_for("ui.form_delete", uuid="all"), follow_redirects=True)
+    assert b'Deleted' in res.data
 
 
 def test_xpath23_prefix_validation(client, live_server, measure_memory_usage):
     # Add our URL to the import page
     test_url = url_for('test_endpoint', _external=True)
-    uuid = client.application.config.get('DATASTORE').add_watch(url=test_url)
-    client.get(url_for("ui.form_watch_checknow"), follow_redirects=True)
+    res = client.post(
+        url_for("imports.import_page"),
+        data={"urls": test_url},
+        follow_redirects=True
+    )
+    assert b"1 Imported" in res.data
     wait_for_all_checks(client)
 
     res = client.post(
         url_for("ui.ui_edit.edit_page", uuid="first"),
-        data={"include_filters": "xpath:/something horrible", "url": test_url, "tags": "", "headers": "", 'fetch_backend': "html_requests", "time_between_check_use_default": "y"},
+        data={"include_filters": "xpath:/something horrible", "url": test_url, "tags": "", "headers": "", 'fetch_backend': "html_requests"},
         follow_redirects=True
     )
     assert b"is not a valid XPath expression" in res.data
-    delete_all_watches(client)
+    res = client.get(url_for("ui.form_delete", uuid="all"), follow_redirects=True)
+    assert b'Deleted' in res.data
 
 def test_xpath1_lxml(client, live_server, measure_memory_usage):
     
@@ -292,14 +287,18 @@ def test_xpath1_lxml(client, live_server, measure_memory_usage):
 
 
     test_url = url_for('test_endpoint', _external=True)
-    uuid = client.application.config.get('DATASTORE').add_watch(url=test_url)
-    client.get(url_for("ui.form_watch_checknow"), follow_redirects=True)
+    res = client.post(
+        url_for("imports.import_page"),
+        data={"urls": test_url},
+        follow_redirects=True
+    )
+    assert b"1 Imported" in res.data
     wait_for_all_checks(client)
 
     res = client.post(
         url_for("ui.ui_edit.edit_page", uuid="first"),
         data={"include_filters": "xpath1://title/text()", "url": test_url, "tags": "", "headers": "",
-              'fetch_backend': "html_requests", "time_between_check_use_default": "y"},
+              'fetch_backend': "html_requests"},
         follow_redirects=True
     )
 
@@ -322,35 +321,45 @@ def test_xpath1_lxml(client, live_server, measure_memory_usage):
 def test_xpath1_validation(client, live_server, measure_memory_usage):
     # Add our URL to the import page
     test_url = url_for('test_endpoint', _external=True)
-    uuid = client.application.config.get('DATASTORE').add_watch(url=test_url)
-    client.get(url_for("ui.form_watch_checknow"), follow_redirects=True)
+    res = client.post(
+        url_for("imports.import_page"),
+        data={"urls": test_url},
+        follow_redirects=True
+    )
+    assert b"1 Imported" in res.data
     wait_for_all_checks(client)
 
     res = client.post(
         url_for("ui.ui_edit.edit_page", uuid="first"),
-        data={"include_filters": "xpath1:/something horrible", "url": test_url, "tags": "", "headers": "", 'fetch_backend': "html_requests", "time_between_check_use_default": "y"},
+        data={"include_filters": "xpath1:/something horrible", "url": test_url, "tags": "", "headers": "", 'fetch_backend': "html_requests"},
         follow_redirects=True
     )
     assert b"is not a valid XPath expression" in res.data
-    delete_all_watches(client)
+    res = client.get(url_for("ui.form_delete", uuid="all"), follow_redirects=True)
+    assert b'Deleted' in res.data
 
 
 # actually only really used by the distll.io importer, but could be handy too
 def test_check_with_prefix_include_filters(client, live_server, measure_memory_usage):
-    delete_all_watches(client)
+    res = client.get(url_for("ui.form_delete", uuid="all"), follow_redirects=True)
+    assert b'Deleted' in res.data
 
     set_original_response()
     wait_for_all_checks(client)
     # Add our URL to the import page
     test_url = url_for('test_endpoint', _external=True)
-    uuid = client.application.config.get('DATASTORE').add_watch(url=test_url)
-    client.get(url_for("ui.form_watch_checknow"), follow_redirects=True)
+    res = client.post(
+        url_for("imports.import_page"),
+        data={"urls": test_url},
+        follow_redirects=True
+    )
+    assert b"1 Imported" in res.data
     wait_for_all_checks(client)
 
     res = client.post(
         url_for("ui.ui_edit.edit_page", uuid="first"),
         data={"include_filters": "xpath://*[contains(@class, 'sametext')]", "url": test_url, "tags": "", "headers": "",
-              'fetch_backend': "html_requests", "time_between_check_use_default": "y"},
+              'fetch_backend': "html_requests"},
         follow_redirects=True
     )
 
@@ -389,8 +398,12 @@ def test_various_rules(client, live_server, measure_memory_usage):
     """)
 
     test_url = url_for('test_endpoint', _external=True)
-    uuid = client.application.config.get('DATASTORE').add_watch(url=test_url)
-    client.get(url_for("ui.form_watch_checknow"), follow_redirects=True)
+    res = client.post(
+        url_for("imports.import_page"),
+        data={"urls": test_url},
+        follow_redirects=True
+    )
+    assert b"1 Imported" in res.data
     wait_for_all_checks(client)
 
     for r in ['//div', '//a', 'xpath://div', 'xpath://a']:
@@ -400,8 +413,7 @@ def test_various_rules(client, live_server, measure_memory_usage):
                   "url": test_url,
                   "tags": "",
                   "headers": "",
-                  'fetch_backend': "html_requests",
-                  "time_between_check_use_default": "y"},
+                  'fetch_backend': "html_requests"},
             follow_redirects=True
         )
         wait_for_all_checks(client)
@@ -409,13 +421,18 @@ def test_various_rules(client, live_server, measure_memory_usage):
         res = client.get(url_for("watchlist.index"))
         assert b'fetch-error' not in res.data, f"Should not see errors after '{r} filter"
 
-    delete_all_watches(client)
+    res = client.get(url_for("ui.form_delete", uuid="all"), follow_redirects=True)
+    assert b'Deleted' in res.data
 
 
 def test_xpath_20(client, live_server, measure_memory_usage):
     test_url = url_for('test_endpoint', _external=True)
-    uuid = client.application.config.get('DATASTORE').add_watch(url=test_url)
-    client.get(url_for("ui.form_watch_checknow"), follow_redirects=True)
+    res = client.post(
+        url_for("imports.import_page"),
+        data={"urls": test_url},
+        follow_redirects=True
+    )
+    assert b"1 Imported" in res.data
     wait_for_all_checks(client)
 
     set_original_response()
@@ -427,8 +444,7 @@ def test_xpath_20(client, live_server, measure_memory_usage):
               "url": test_url,
               "tags": "",
               "headers": "",
-              'fetch_backend': "html_requests",
-              "time_between_check_use_default": "y"},
+              'fetch_backend': "html_requests"},
         follow_redirects=True
     )
 
@@ -451,8 +467,12 @@ def test_xpath_20_function_count(client, live_server, measure_memory_usage):
 
     # Add our URL to the import page
     test_url = url_for('test_endpoint', _external=True)
-    uuid = client.application.config.get('DATASTORE').add_watch(url=test_url)
-    client.get(url_for("ui.form_watch_checknow"), follow_redirects=True)
+    res = client.post(
+        url_for("imports.import_page"),
+        data={"urls": test_url},
+        follow_redirects=True
+    )
+    assert b"1 Imported" in res.data
     wait_for_all_checks(client)
 
     res = client.post(
@@ -461,8 +481,7 @@ def test_xpath_20_function_count(client, live_server, measure_memory_usage):
               "url": test_url,
               "tags": "",
               "headers": "",
-              'fetch_backend': "html_requests",
-              "time_between_check_use_default": "y"},
+              'fetch_backend': "html_requests"},
         follow_redirects=True
     )
 
@@ -484,8 +503,12 @@ def test_xpath_20_function_count2(client, live_server, measure_memory_usage):
 
     # Add our URL to the import page
     test_url = url_for('test_endpoint', _external=True)
-    uuid = client.application.config.get('DATASTORE').add_watch(url=test_url)
-    client.get(url_for("ui.form_watch_checknow"), follow_redirects=True)
+    res = client.post(
+        url_for("imports.import_page"),
+        data={"urls": test_url},
+        follow_redirects=True
+    )
+    assert b"1 Imported" in res.data
     wait_for_all_checks(client)
 
     res = client.post(
@@ -494,8 +517,7 @@ def test_xpath_20_function_count2(client, live_server, measure_memory_usage):
               "url": test_url,
               "tags": "",
               "headers": "",
-              'fetch_backend': "html_requests",
-              "time_between_check_use_default": "y"},
+              'fetch_backend': "html_requests"},
         follow_redirects=True
     )
 
@@ -517,19 +539,22 @@ def test_xpath_20_function_string_join_matches(client, live_server, measure_memo
 
     # Add our URL to the import page
     test_url = url_for('test_endpoint', _external=True)
-    uuid = client.application.config.get('DATASTORE').add_watch(url=test_url)
-    client.get(url_for("ui.form_watch_checknow"), follow_redirects=True)
+    res = client.post(
+        url_for("imports.import_page"),
+        data={"urls": test_url},
+        follow_redirects=True
+    )
+    assert b"1 Imported" in res.data
     wait_for_all_checks(client)
 
     res = client.post(
-        url_for("ui.ui_edit.edit_page", uuid=uuid),
+        url_for("ui.ui_edit.edit_page", uuid="first"),
         data={
             "include_filters": "xpath:string-join(//*[contains(@class, 'sametext')]|//*[matches(@class, 'changetext')], 'specialconjunction')",
             "url": test_url,
             "tags": "",
             "headers": "",
-            'fetch_backend': "html_requests",
-            "time_between_check_use_default": "y"},
+            'fetch_backend': "html_requests"},
         follow_redirects=True
     )
 
@@ -537,7 +562,7 @@ def test_xpath_20_function_string_join_matches(client, live_server, measure_memo
     wait_for_all_checks(client)
 
     res = client.get(
-        url_for("ui.ui_views.preview_page", uuid=uuid),
+        url_for("ui.ui_views.preview_page", uuid="first"),
         follow_redirects=True
     )
 
@@ -545,47 +570,3 @@ def test_xpath_20_function_string_join_matches(client, live_server, measure_memo
 
     client.get(url_for("ui.form_delete", uuid="all"), follow_redirects=True)
 
-
-def _subtest_xpath_rss(client, content_type='text/html'):
-
-    # Add our URL to the import page
-    test_url = url_for('test_endpoint', content_type=content_type, _external=True)
-    res = client.post(
-        url_for("ui.ui_views.form_quick_watch_add"),
-        data={"url": test_url, "tags": '', 'edit_and_watch_submit_button': 'Edit > Watch'},
-        follow_redirects=True
-    )
-
-    assert b"Watch added in Paused state, saving will unpause" in res.data
-
-    res = client.post(
-        url_for("ui.ui_edit.edit_page", uuid="first", unpause_on_save=1),
-        data={
-            "url": test_url,
-            "include_filters": "xpath://item",
-            "tags": '',
-            "fetch_backend": "html_requests",
-            "time_between_check_use_default": "y",
-        },
-        follow_redirects=True
-    )
-
-    assert b"unpaused" in res.data
-    wait_for_all_checks(client)
-
-    res = client.get(
-        url_for("ui.ui_views.preview_page", uuid="first"),
-        follow_redirects=True
-    )
-
-    assert b"Lets go discount" in res.data, f"When testing for Lets go discount called with content type '{content_type}'"
-    assert b"Events and Announcements" not in res.data, f"When testing for Lets go discount called with content type '{content_type}'" # It should not be here because thats not our selector target
-
-    client.get(url_for("ui.form_delete", uuid="all"), follow_redirects=True)
-
-# Be sure all-in-the-wild types of RSS feeds work with xpath
-def test_rss_xpath(client, live_server, measure_memory_usage):
-    for feed_header in ['', '<?xml version="1.0" encoding="utf-8"?>']:
-        set_rss_atom_feed_response(header=feed_header)
-        for content_type in RSS_XML_CONTENT_TYPES:
-            _subtest_xpath_rss(client, content_type=content_type)

changedetectionio/tests/util.py

@@ -127,11 +127,6 @@ def extract_UUID_from_client(client):
     uuid = m.group(1)
     return uuid.strip()
 
-def delete_all_watches(client=None):
-    uuids = list(client.application.config.get('DATASTORE').data['watching'])
-    for uuid in uuids:
-        client.application.config.get('DATASTORE').delete(uuid)
-
 
 def wait_for_all_checks(client=None):
     """
@@ -140,6 +135,8 @@ def wait_for_all_checks(client=None):
     """
     from changedetectionio.flask_app import update_q as global_update_q
     from changedetectionio import worker_handler
+
+    logger = logging.getLogger()
     empty_since = None
     attempt = 0
     max_attempts = 150  # Still reasonable upper bound
@@ -147,9 +144,9 @@ def wait_for_all_checks(client=None):
     while attempt < max_attempts:
         # Start with fast checks, slow down if needed
         if attempt < 10:
-            time.sleep(0.2)  # Very fast initial checks
+            time.sleep(0.1)  # Very fast initial checks
         elif attempt < 30:
-            time.sleep(0.4)  # Medium speed
+            time.sleep(0.3)  # Medium speed
         else:
             time.sleep(0.8)  # Slower for persistent issues
 
@@ -325,3 +322,4 @@ def new_live_server_setup(live_server):
         return resp
 
     live_server.start()
+

changedetectionio/tests/visualselector/test_fetch_data.py

@@ -4,7 +4,7 @@ import os
 from flask import url_for
 from ..util import live_server_setup, wait_for_all_checks
 
-# def test_setup(client, live_server, measure_memory_usage):
+# def test_setup(client, live_server):
    #  live_server_setup(live_server) # Setup on conftest per function
 
 
@@ -36,7 +36,6 @@ def test_visual_selector_content_ready(client, live_server, measure_memory_usage
             # For now, cookies doesnt work in headers because it must be a full cookiejar object
             'headers': "testheader: yes\buser-agent: MyCustomAgent",
             'fetch_backend': "html_webdriver",
-            "time_between_check_use_default": "y",
         },
         follow_redirects=True
     )
@@ -117,7 +116,6 @@ def test_basic_browserstep(client, live_server, measure_memory_usage):
             'browser_steps-1-optional_value': '',
             # For now, cookies doesnt work in headers because it must be a full cookiejar object
             'headers': "testheader: yes\buser-agent: MyCustomAgent",
-            "time_between_check_use_default": "y",
         },
         follow_redirects=True
     )
@@ -142,7 +140,7 @@ def test_basic_browserstep(client, live_server, measure_memory_usage):
     assert b"testheader: yes" in res.data
     assert b"user-agent: mycustomagent" in res.data
 
-def test_non_200_errors_report_browsersteps(client, live_server, measure_memory_usage):
+def test_non_200_errors_report_browsersteps(client, live_server):
 
 
     four_o_four_url =  url_for('test_endpoint', status_code=404, _external=True)
@@ -169,8 +167,7 @@ def test_non_200_errors_report_browsersteps(client, live_server, measure_memory_
               'fetch_backend': "html_webdriver",
               'browser_steps-0-operation': 'Click element',
               'browser_steps-0-selector': 'button[name=test-button]',
-              'browser_steps-0-optional_value': '',
-              "time_between_check_use_default": "y"
+              'browser_steps-0-optional_value': ''
         },
         follow_redirects=True
     )

docs/api-spec.yaml

@@ -1,4 +1,4 @@
-openapi: 3.1.0
+openapi: 3.0.3
 info:
   title: ChangeDetection.io API
   description: |
@@ -28,7 +28,7 @@ info:
     
     For example: `x-api-key: YOUR_API_KEY`
     
-  version: 0.1.1
+  version: 0.1.0
   contact:
     name: ChangeDetection.io
     url: https://github.com/dgtlmoon/changedetection.io
@@ -129,7 +129,7 @@ components:
           maxLength: 5000
         title:
           type: string
-          description: Custom title for the web page change monitor (watch), not to be confused with page_title
+          description: Custom title for the web page change monitor (watch)
           maxLength: 5000
         tag:
           type: string
@@ -188,10 +188,6 @@ components:
             seconds:
               type: integer
           description: Time intervals between checks
-        time_between_check_use_default:
-          type: boolean
-          default: true
-          description: Whether to use global settings for time between checks - defaults to true if not set
         notification_urls:
           type: array
           items:
@@ -228,6 +224,8 @@ components:
                 maxLength: 5000
             required: [operation, selector, optional_value]
           description: Browser automation steps
+      required:
+        - url
 
     Watch:
       allOf:
@@ -255,11 +253,6 @@ components:
               type: integer
               description: Unix timestamp in seconds of the last time the watch was viewed. Setting it to a value higher than `last_changed` in the "Update watch" endpoint marks the watch as viewed.
               minimum: 0
-            link:
-              type: string
-              format: string
-              description: The watch URL rendered in case of any Jinja2 markup, always use this for listing.
-              readOnly: true
 
     CreateWatch:
       allOf:
@@ -268,16 +261,6 @@ components:
           required:
             - url
 
-    UpdateWatch:
-      allOf:
-        - $ref: '#/components/schemas/WatchBase'
-        - type: object
-          properties:
-            last_viewed:
-              type: integer
-              description: Unix timestamp in seconds of the last time the watch was viewed. Setting it to a value higher than `last_changed` in the "Update watch" endpoint marks the watch as viewed.
-              minimum: 0
-
     Tag:
       type: object
       properties:
@@ -298,13 +281,8 @@ components:
         notification_muted:
           type: boolean
           description: Whether notifications are muted for this tag
-
-    CreateTag:
-      allOf:
-        - $ref: '#/components/schemas/Tag'
-        - type: object
-          required:
-            - title
+      required:
+        - title
 
     NotificationUrls:
       type: object
@@ -400,10 +378,9 @@ paths:
               example:
                 "095be615-a8ad-4c33-8e9c-c7612fbf6c9f":
                   uuid: "095be615-a8ad-4c33-8e9c-c7612fbf6c9f"
-                  url: "http://example.com?id={{1+1}} - the raw URL"
-                  link: "http://example.com?id=2 - the rendered URL, always use this for listing."
-                  title: "Example Website Monitor - manually entered title/description"
-                  page_title: "The HTML <title> from the page"
+                  url: "http://example.com"
+                  title: "Example Website Monitor"
+                  tag: "550e8400-e29b-41d4-a716-446655440000"
                   tags: ["550e8400-e29b-41d4-a716-446655440000"]
                   paused: false
                   muted: false
@@ -413,10 +390,9 @@ paths:
                   last_changed: 1640995200
                 "7c9e6b8d-f2a1-4e5c-9d3b-8a7f6e4c2d1a":
                   uuid: "7c9e6b8d-f2a1-4e5c-9d3b-8a7f6e4c2d1a"
-                  url: "http://example.com?id={{1+1}} - the raw URL"
-                  link: "http://example.com?id=2 - the rendered URL, always use this for listing."
-                  title: "News Site Tracker - manually entered title/description"
-                  page_title: "The HTML <title> from the page"
+                  url: "https://news.example.org"
+                  title: "News Site Tracker"
+                  tag: "330e8400-e29b-41d4-a716-446655440001"
                   tags: ["330e8400-e29b-41d4-a716-446655440001"]
                   paused: false
                   muted: true
@@ -596,7 +572,7 @@ paths:
         content:
           application/json:
             schema:
-              $ref: '#/components/schemas/UpdateWatch'
+              $ref: '#/components/schemas/Watch'
       responses:
         '200':
           description: Web page change monitor (watch) updated successfully
@@ -839,7 +815,7 @@ paths:
                 'Content-Type': 'application/json'
             }
             data = {'title': 'Important Sites'}
-            response = requests.post('http://localhost:5000/api/v1/tag',
+            response = requests.post('http://localhost:5000/api/v1/tag', 
                                    headers=headers, json=data)
             print(response.json())
       requestBody:
@@ -847,7 +823,7 @@ paths:
         content:
           application/json:
             schema:
-              $ref: '#/components/schemas/CreateTag'
+              $ref: '#/components/schemas/Tag'
             example:
               title: "Important Sites"
       responses:
@@ -1222,6 +1198,7 @@ paths:
                     uuid: "095be615-a8ad-4c33-8e9c-c7612fbf6c9f"
                     url: "http://example.com"
                     title: "Example Website Monitor"
+                    tag: "550e8400-e29b-41d4-a716-446655440000"
                     tags: ["550e8400-e29b-41d4-a716-446655440000"]
                     paused: false
                     muted: false

requirements.txt

@@ -12,7 +12,7 @@ flask_wtf~=1.2
 flask~=2.3
 flask-socketio~=5.5.1
 python-socketio~=5.13.0
-python-engineio~=4.12.3
+python-engineio~=4.12.0
 inscriptis~=2.2
 pytz
 timeago~=1.0
@@ -39,7 +39,7 @@ jsonpath-ng~=1.5.3
 # jq not available on Windows so must be installed manually
 
 # Notification library
-apprise==1.9.5
+apprise==1.9.3
 
 # - Needed for apprise/spush, and maybe others? hopefully doesnt trigger a rust compile.
 # - Requires extra wheel for rPi, adds build time for arm/v8 which is not in piwheels
@@ -51,8 +51,8 @@ cryptography==44.0.1
 # use any version other than 2.0.x due to https://github.com/eclipse/paho.mqtt.python/issues/814
 paho-mqtt!=2.0.*
 
-# Used for CSS filtering, JSON extraction from HTML
-beautifulsoup4>=4.0.0,<=4.13.5
+# Used for CSS filtering
+beautifulsoup4>=4.0.0
 
 # XPath filtering, lxml is required by bs4 anyway, but put it here to be safe.
 # #2328 - 5.2.0 and 5.2.1 had extra CPU flag CFLAGS set which was not compatible on older hardware
@@ -135,7 +135,7 @@ tzdata
 pluggy ~= 1.5
 
 # Needed for testing, cross-platform for process and system monitoring
-psutil==7.1.0
+psutil==7.0.0
 
 ruff >= 0.11.2
 pre_commit >= 4.2.0