• Search by Module
• Search by Words
• Search Projects

• Java
• Python
• JavaScript
• TypeScript
• C++
• Scala
• Blog

• django-postgres-extra-master
  • .circleci
    • config.yml
  • .prospector.yaml
  • .coveragerc
  • psqlextra
    • apps.py
    • sql.py
    • util.py
    • expressions.py
    • type_assertions.py
    • backend
      • introspection.py
      • schema.py
      • base_impl.py
      • __init__.py
      • migrations
        • operations
          • create_view_model.py
          • apply_state.py
          • delete_view_model.py
          • add_default_partition.py
          • add_range_partition.py
          • delete_materialized_view_model.py
          • add_list_partition.py
          • create_materialized_view_model.py
          • delete_partitioned_model.py
          • delete_partition.py
          • create_partitioned_model.py
          • partition.py
          • __init__.py
          • delete_range_partition.py
          • delete_list_partition.py
          • delete_default_partition.py
        • state
          • materialized_view.py
          • model.py
          • __init__.py
          • view.py
          • partitioning.py
        • patched_project_state.py
        • patched_autodetector.py
        • __init__.py
        • README.md
        • patched_migrations.py
      • side_effects
        • hstore_required.py
        • __init__.py
        • hstore_unique.py
      • base.py
      • operations.py
    • models
      • options.py
      • __init__.py
      • partitioned.py
      • view.py
      • base.py
    • fields
      • hstore_field.py
      • __init__.py
    • query.py
    • __init__.py
    • compiler.py
    • partitioning
      • current_time_strategy.py
      • time_partition_size.py
      • config.py
      • time_strategy.py
      • range_partition.py
      • constants.py
      • manager.py
      • range_strategy.py
      • partition.py
      • __init__.py
      • shorthands.py
      • error.py
      • plan.py
      • strategy.py
      • time_partition.py
    • manager
      • manager.py
      • __init__.py
    • types.py
    • indexes
      • case_insensitive_unique_index.py
      • conditional_unique_index.py
      • __init__.py
    • management
      • commands
        • pgpartition.py
        • pgmakemigrations.py
        • pgrefreshmv.py
        • __init__.py
      • __init__.py
  • LICENSE
  • .readthedocs.yml
  • manage.py
  • CONTRIBUTING.md
  • setup.py
  • setup.cfg
  • README.md
  • tests
    • fake_model.py
    • test_schema_editor_view.py
    • test_on_conflict.py
    • test_partitioned_model.py
    • test_db_backend.py
    • test_manager_context.py
    • test_upsert.py
    • test_insert.py
    • db_introspection.py
    • test_view_models.py
    • snapshots
      • __init__.py
      • snap_test_management_command_partition.py
    • test_partitioning_manager.py
    • test_management_command_partition.py
    • test_query.py
    • test_migration_operations.py
    • test_conditional_unique_index.py
    • test_schema_editor_partitioning.py
    • benchmarks
      • test_upsert.py
      • test_insert_nothing.py
      • __init__.py
      • test_upsert_bulk.py
    • test_partitioning_time.py
    • test_materialized_view_model.py
    • test_on_conflict_update.py
    • test_hstore_required.py
    • __init__.py
    • test_hstore_autodetect.py
    • test_query_values.py
    • test_hstore_unique.py
    • test_partitioned_model_state.py
    • test_hstore_field.py
    • test_make_migrations.py
    • test_case_insensitive_unique_index.py
    • migrations.py
    • test_on_conflict_nothing.py
    • conftest.py
    • test_manager.py
  • pytest.ini
  • settings.py
  • pyproject.toml
  • .gitignore
  • docs
    • Makefile
    • source
      • conflict_handling.rst
      • expressions.rst
      • table_partitioning.rst
      • deletion.rst
      • snippets
        • manager_model_warning.rst
        • postgres_doc_links.rst
        • django_doc_links.rst
      • annotations.rst
      • hstore.rst
      • indexes.rst
      • major_releases.rst
      • api_reference.rst
      • settings.rst
      • index.rst
      • conf.py
      • managers_models.rst
      • installation.rst
    • make.bat
    • .gitignore
  • pytest-benchmark.ini
  • tox.ini

import pytest

from django.apps import apps
from django.db import models
from django.db.migrations import AddField, AlterField, RemoveField
from django.db.migrations.state import ProjectState

from psqlextra.backend.migrations import operations, postgres_patched_migrations
from psqlextra.models import (
    PostgresMaterializedViewModel,
    PostgresPartitionedModel,
    PostgresViewModel,
)
from psqlextra.types import PostgresPartitioningMethod

from .fake_model import (
    define_fake_materialized_view_model,
    define_fake_partitioned_model,
    define_fake_view_model,
    get_fake_model,
)
from .migrations import apply_migration, make_migration


@pytest.mark.parametrize(
    "model_config",
    [
        dict(
            fields={"category": models.TextField()},
            partitioning_options=dict(
                method=PostgresPartitioningMethod.LIST, key="category"
            ),
        ),
        dict(
            fields={"timestamp": models.DateTimeField()},
            partitioning_options=dict(
                method=PostgresPartitioningMethod.RANGE, key="timestamp"
            ),
        ),
    ],
)
@postgres_patched_migrations()
def test_make_migration_create_partitioned_model(fake_app, model_config):
    """Tests whether the right operations are generated when creating a new
    partitioned model."""

    model = define_fake_partitioned_model(
        **model_config, meta_options=dict(app_label=fake_app.name)
    )

    migration = make_migration(model._meta.app_label)
    ops = migration.operations

    # should have one operation to create the partitioned model
    # and one more to add a default partition
    assert len(ops) == 2
    assert isinstance(ops[0], operations.PostgresCreatePartitionedModel)
    assert isinstance(ops[1], operations.PostgresAddDefaultPartition)

    # make sure the base is set correctly
    assert len(ops[0].bases) == 1
    assert issubclass(ops[0].bases[0], PostgresPartitionedModel)

    # make sure the partitioning options got copied correctly
    assert ops[0].partitioning_options == model_config["partitioning_options"]

    # make sure the default partition is named "default"
    assert ops[1].model_name == model.__name__
    assert ops[1].name == "default"


@postgres_patched_migrations()
def test_make_migration_create_view_model(fake_app):
    """Tests whether the right operations are generated when creating a new
    view model."""

    underlying_model = get_fake_model({"name": models.TextField()})

    model = define_fake_view_model(
        fields={"name": models.TextField()},
        view_options=dict(query=underlying_model.objects.all()),
        meta_options=dict(app_label=fake_app.name),
    )

    migration = make_migration(model._meta.app_label)
    ops = migration.operations

    assert len(ops) == 1
    assert isinstance(ops[0], operations.PostgresCreateViewModel)

    # make sure the base is set correctly
    assert len(ops[0].bases) == 1
    assert issubclass(ops[0].bases[0], PostgresViewModel)

    # make sure the view options got copied correctly
    assert ops[0].view_options == model._view_meta.original_attrs


@postgres_patched_migrations()
def test_make_migration_create_materialized_view_model(fake_app):
    """Tests whether the right operations are generated when creating a new
    materialized view model."""

    underlying_model = get_fake_model({"name": models.TextField()})

    model = define_fake_materialized_view_model(
        fields={"name": models.TextField()},
        view_options=dict(query=underlying_model.objects.all()),
        meta_options=dict(app_label=fake_app.name),
    )

    migration = make_migration(model._meta.app_label)
    ops = migration.operations

    assert len(ops) == 1
    assert isinstance(ops[0], operations.PostgresCreateMaterializedViewModel)

    # make sure the base is set correctly
    assert len(ops[0].bases) == 1
    assert issubclass(ops[0].bases[0], PostgresMaterializedViewModel)

    # make sure the view options got copied correctly
    assert ops[0].view_options == model._view_meta.original_attrs


@pytest.mark.parametrize(
    "define_view_model",
    [define_fake_materialized_view_model, define_fake_view_model],
)
@postgres_patched_migrations()
def test_make_migration_field_operations_view_models(
    fake_app, define_view_model
):
    """Tests whether field operations against a (materialized) view are always
    wrapped in the :see:ApplyState operation so that they don't actually get
    applied to the database, yet Django applies to them to the project state.

    This is important because you can't actually alter/add or delete
    fields from a (materialized) view.
    """

    underlying_model = get_fake_model(
        {"first_name": models.TextField(), "last_name": models.TextField()},
        meta_options=dict(app_label=fake_app.name),
    )

    model = define_view_model(
        fields={"first_name": models.TextField()},
        view_options=dict(query=underlying_model.objects.all()),
        meta_options=dict(app_label=fake_app.name),
    )

    state_1 = ProjectState.from_apps(apps)

    migration = make_migration(model._meta.app_label)
    apply_migration(migration.operations, state_1)

    # add a field to the materialized view
    last_name_field = models.TextField(null=True)
    last_name_field.contribute_to_class(model, "last_name")

    migration = make_migration(model._meta.app_label, from_state=state_1)
    assert len(migration.operations) == 1
    assert isinstance(migration.operations[0], operations.ApplyState)
    assert isinstance(migration.operations[0].state_operation, AddField)

    # alter the field on the materialized view
    state_2 = ProjectState.from_apps(apps)
    last_name_field = models.TextField(null=True, blank=True)
    last_name_field.contribute_to_class(model, "last_name")

    migration = make_migration(model._meta.app_label, from_state=state_2)
    assert len(migration.operations) == 1
    assert isinstance(migration.operations[0], operations.ApplyState)
    assert isinstance(migration.operations[0].state_operation, AlterField)

    # remove the field from the materialized view
    migration = make_migration(
        model._meta.app_label,
        from_state=ProjectState.from_apps(apps),
        to_state=state_1,
    )
    assert isinstance(migration.operations[0], operations.ApplyState)
    assert isinstance(migration.operations[0].state_operation, RemoveField)