- {% for field in fieldset.fields %}
- {% with field=form|get_field:field %}{{ field.as_field_group }}{% endwith %}
- {% endfor %}
- {% for subfieldset in fieldset.fieldsets %}
- {% if subfieldset.fields %}
-
-
{{ subfieldset.title }}
- {% for field in subfieldset.fields %}
- {% with field=form|get_field:field %}{{ field.as_field_group }}{% endwith %}
- {% endfor %}
-
+
+ {% if expert_form %}
+
+ {% endif %}
+ {% if form %}
+
+ {% endif %}
-
+ {# browser form validation fails when there are fields missing/invalid that are hidden #}
+
-
+
+{% if form %}
+
+{% endif %}
diff --git a/src/servala/frontend/templatetags/get_field.py b/src/servala/frontend/templatetags/get_field.py
index 3214beb..2141178 100644
--- a/src/servala/frontend/templatetags/get_field.py
+++ b/src/servala/frontend/templatetags/get_field.py
@@ -1,3 +1,5 @@
+from contextlib import suppress
+
from django import template
register = template.Library()
@@ -5,4 +7,5 @@ register = template.Library()
@register.filter
def get_field(form, field_name):
- return form[field_name]
+ with suppress(KeyError):
+ return form[field_name]
diff --git a/src/servala/frontend/views/service.py b/src/servala/frontend/views/service.py
index 689f381..0f9800e 100644
--- a/src/servala/frontend/views/service.py
+++ b/src/servala/frontend/views/service.py
@@ -123,7 +123,9 @@ class ServiceOfferingDetailView(OrganizationViewMixin, HtmxViewMixin, DetailView
def context_object(self):
if self.request.method == "POST":
return ControlPlaneCRD.objects.filter(
- pk=self.request.POST.get("context"),
+ pk=self.request.POST.get(
+ "expert-context", self.request.POST.get("custom-context")
+ ),
# Make sure we don’t use a malicious ID
control_plane__in=self.planes,
).first()
@@ -131,37 +133,59 @@ class ServiceOfferingDetailView(OrganizationViewMixin, HtmxViewMixin, DetailView
control_plane=self.selected_plane, service_offering=self.object
).first()
- def get_instance_form(self):
- if not self.context_object or not self.context_object.model_form_class:
- return None
-
- initial = {
- "organization": self.request.organization,
- "context": self.context_object,
+ def get_instance_form_kwargs(self, ignore_data=False):
+ return {
+ "initial": {
+ "organization": self.request.organization,
+ "context": self.context_object,
+ },
+ "prefix": "expert",
+ "data": (
+ self.request.POST
+ if (self.request.method == "POST" and not ignore_data)
+ else None
+ ),
}
- # Pre-populate FQDN field if it exists and control plane has wildcard DNS
- form_class = self.context_object.model_form_class
- if (
- "spec.parameters.service.fqdn" in form_class.base_fields
- and self.context_object.control_plane.wildcard_dns
- ):
- # Generate initial FQDN: instancename-namespace.wildcard_dns
- # We'll set a placeholder that JavaScript will replace dynamically
- initial["spec.parameters.service.fqdn"] = ""
+ def get_instance_form(self, ignore_data=False):
+ if not self.context_object or not self.context_object.model_form_class:
+ return
- return form_class(
- data=self.request.POST if self.request.method == "POST" else None,
- initial=initial,
+ return self.context_object.model_form_class(
+ **self.get_instance_form_kwargs(ignore_data=ignore_data)
)
+ def get_custom_instance_form(self, ignore_data=False):
+ if not self.context_object or not self.context_object.custom_model_form_class:
+ return
+ kwargs = self.get_instance_form_kwargs(ignore_data=ignore_data)
+ kwargs["prefix"] = "custom"
+ return self.context_object.custom_model_form_class(**kwargs)
+
+ @property
+ def is_custom_form(self):
+ # Note: "custom form" = user-friendly, subset of fields
+ # vs "expert form" = auto-generated (all technical fields)
+ return self.request.POST.get("active_form", "expert") == "custom"
+
def get_context_data(self, **kwargs):
context = super().get_context_data(**kwargs)
context["select_form"] = self.select_form
context["has_control_planes"] = self.planes.exists()
context["selected_plane"] = self.selected_plane
- context["service_form"] = self.get_instance_form()
- # Pass data for dynamic FQDN generation
+ if self.request.method == "POST":
+ if self.is_custom_form:
+ context["service_form"] = self.get_instance_form(ignore_data=True)
+ context["custom_service_form"] = self.get_custom_instance_form()
+ else:
+ context["service_form"] = self.get_instance_form()
+ context["custom_service_form"] = self.get_custom_instance_form(
+ ignore_data=True
+ )
+ else:
+ context["service_form"] = self.get_instance_form()
+ context["custom_service_form"] = self.get_custom_instance_form()
+
if self.selected_plane and self.selected_plane.wildcard_dns:
context["wildcard_dns"] = self.selected_plane.wildcard_dns
context["organization_namespace"] = self.request.organization.namespace
@@ -175,7 +199,10 @@ class ServiceOfferingDetailView(OrganizationViewMixin, HtmxViewMixin, DetailView
context["form_error"] = True
return self.render_to_response(context)
- form = self.get_instance_form()
+ if self.is_custom_form:
+ form = self.get_custom_instance_form()
+ else:
+ form = self.get_instance_form()
if not form: # Should not happen if context_object is valid, but as a safeguard
messages.error(
self.request,
@@ -203,8 +230,6 @@ class ServiceOfferingDetailView(OrganizationViewMixin, HtmxViewMixin, DetailView
)
form.add_error(None, error_message)
- # If the form is not valid or if the service creation failed, we render it again
- context["service_form"] = form
return self.render_to_response(context)
@@ -393,11 +418,75 @@ class ServiceInstanceUpdateView(
def get_form_kwargs(self):
kwargs = super().get_form_kwargs()
kwargs["instance"] = self.object.spec_object
+ kwargs["prefix"] = "expert"
return kwargs
+ def get_form(self, *args, ignore_data=False, **kwargs):
+ if not ignore_data:
+ return super().get_form(*args, **kwargs)
+ cls = self.get_form_class()
+ kwargs = self.get_form_kwargs()
+ if ignore_data:
+ kwargs.pop("data", None)
+ return cls(**kwargs)
+
+ def get_custom_form(self, ignore_data=False):
+ cls = self.object.context.custom_model_form_class
+ if not cls:
+ return
+ kwargs = self.get_form_kwargs()
+ kwargs["prefix"] = "custom"
+ if ignore_data:
+ kwargs.pop("data", None)
+ return cls(**kwargs)
+
+ @property
+ def is_custom_form(self):
+ # Note: "custom form" = user-friendly, subset of fields
+ # vs "expert form" = auto-generated (all technical fields)
+ return self.request.POST.get("active_form", "expert") == "custom"
+
+ def post(self, request, *args, **kwargs):
+ self.object = self.get_object()
+
+ if self.is_custom_form:
+ form = self.get_custom_form()
+ else:
+ form = self.get_form()
+
+ if form.is_valid():
+ return self.form_valid(form)
+ return self.form_invalid(form)
+
+ def get_context_data(self, **kwargs):
+ context = super().get_context_data(**kwargs)
+ if self.request.method == "POST":
+ if self.is_custom_form:
+ context["custom_form"] = self.get_custom_form()
+ context["form"] = self.get_form(ignore_data=True)
+ else:
+ context["custom_form"] = self.get_custom_form(ignore_data=True)
+ else:
+ context["custom_form"] = self.get_custom_form()
+ return context
+
+ def _deep_merge(self, base, update):
+ for key, value in update.items():
+ if key in base and isinstance(base[key], dict) and isinstance(value, dict):
+ self._deep_merge(base[key], value)
+ else:
+ base[key] = value
+ return base
+
def form_valid(self, form):
try:
- spec_data = form.get_nested_data().get("spec")
+ form_data = form.get_nested_data()
+ spec_data = form_data.get("spec")
+
+ if self.is_custom_form:
+ current_spec = dict(self.object.spec) if self.object.spec else {}
+ spec_data = self._deep_merge(current_spec, spec_data)
+
self.object.update_spec(spec_data=spec_data, updated_by=self.request.user)
messages.success(
self.request,
diff --git a/src/servala/static/css/servala.css b/src/servala/static/css/servala.css
index cb7061a..cc69a4f 100644
--- a/src/servala/static/css/servala.css
+++ b/src/servala/static/css/servala.css
@@ -237,42 +237,42 @@ a.btn-keycloak {
flex-grow: 1;
}
-/* CRD Form mandatory field styling */
-.crd-form .form-group.mandatory .form-label {
+/* Expert CRD Form mandatory field styling */
+.expert-crd-form .form-group.mandatory .form-label {
font-weight: bold;
position: relative;
}
-.crd-form .form-group.mandatory .form-label::after {
+.expert-crd-form .form-group.mandatory .form-label::after {
content: " *";
color: #dc3545;
font-weight: bold;
}
-.crd-form .form-group.mandatory {
+.expert-crd-form .form-group.mandatory {
border-left: 3px solid #dc3545;
padding-left: 10px;
background-color: rgba(220, 53, 69, 0.05);
border-radius: 3px;
}
-.crd-form .nav-tabs .nav-link .mandatory-indicator {
+.expert-crd-form .nav-tabs .nav-link .mandatory-indicator {
color: #dc3545;
font-weight: bold;
font-size: 1.1em;
margin-left: 4px;
}
-html[data-bs-theme="dark"] .crd-form .form-group.mandatory {
+html[data-bs-theme="dark"] .expert-crd-form .form-group.mandatory {
background-color: rgba(220, 53, 69, 0.1);
border-left-color: #ff6b6b;
}
-html[data-bs-theme="dark"] .crd-form .form-group.mandatory .form-label::after {
+html[data-bs-theme="dark"] .expert-crd-form .form-group.mandatory .form-label::after {
color: #ff6b6b;
}
-html[data-bs-theme="dark"] .crd-form .nav-tabs .nav-link .mandatory-indicator {
+html[data-bs-theme="dark"] .expert-crd-form .nav-tabs .nav-link .mandatory-indicator {
color: #ff6b6b;
}
@@ -306,33 +306,6 @@ html[data-bs-theme="dark"] .crd-form .nav-tabs .nav-link .mandatory-indicator {
margin-left: auto !important
}
-/* Advanced fields tab flash animation */
-@keyframes tab-pulse {
- 0%, 100% {
- background-color: transparent;
- box-shadow: none;
- }
- 50% {
- background-color: var(--brand-light);
- box-shadow: 0 0 10px rgba(154, 99, 236, 0.3);
- }
-}
-
-html[data-bs-theme="dark"] @keyframes tab-pulse {
- 0%, 100% {
- background-color: transparent;
- box-shadow: none;
- }
- 50% {
- background-color: rgba(154, 99, 236, 0.2);
- box-shadow: 0 0 10px rgba(154, 99, 236, 0.4);
- }
-}
-
-.nav-tabs .nav-link.tab-flash {
- animation: tab-pulse 1s ease-in-out 2;
-}
-
.beta-banner {
background: linear-gradient(135deg, var(--bs-primary) 0%, var(--brand-mid) 100%);
color: white;
diff --git a/src/servala/static/js/advanced-fields.js b/src/servala/static/js/advanced-fields.js
deleted file mode 100644
index 989e61a..0000000
--- a/src/servala/static/js/advanced-fields.js
+++ /dev/null
@@ -1,83 +0,0 @@
-/**
- * Advanced Fields Toggle
- * Handles showing/hiding advanced fields in CRD forms
- */
-(function() {
- 'use strict';
-
- function flashTabsWithAdvancedFields() {
- const advancedGroups = document.querySelectorAll('.advanced-field-group');
- const tabsToFlash = new Set();
- advancedGroups.forEach(function(group) {
- const tabPane = group.closest('.tab-pane');
- if (tabPane) {
- const tabId = tabPane.getAttribute('id');
- if (tabId) {
- const tabButton = document.querySelector(`[data-bs-target="#${tabId}"]`);
- if (tabButton && !tabButton.classList.contains('active')) {
- tabsToFlash.add(tabButton);
- }
- }
- }
- });
-
- tabsToFlash.forEach(function(tab) {
- tab.classList.add('tab-flash');
- setTimeout(function() {
- tab.classList.remove('tab-flash');
- }, 2000);
- });
- }
-
- function initializeAdvancedFields() {
- const advancedInputs = document.querySelectorAll('[data-advanced="true"]');
-
- if (advancedInputs.length === 0) {
- return;
- }
-
- advancedInputs.forEach(function(input) {
- const formGroup = input.closest('.form-group, .mb-3, .col-12, .col-md-6');
- if (formGroup) {
- formGroup.classList.add('advanced-field-group', 'collapse');
- }
- });
-
- const toggleButton = document.getElementById('advanced-toggle');
- if (toggleButton) {
- let isExpanded = false;
-
- document.querySelectorAll('.advanced-field-group').forEach(function(group) {
- group.addEventListener('shown.bs.collapse', function() {
- toggleButton.innerHTML = '
Hide Advanced Options';
- if (!isExpanded) {
- isExpanded = true;
- setTimeout(flashTabsWithAdvancedFields, 100);
- }
- });
-
- group.addEventListener('hidden.bs.collapse', function() {
- const anyVisible = Array.from(document.querySelectorAll('.advanced-field-group')).some(
- g => g.classList.contains('show')
- );
- if (!anyVisible) {
- toggleButton.innerHTML = '
Show Advanced Options';
- isExpanded = false;
- }
- });
- });
- }
- }
-
- if (document.readyState === 'loading') {
- document.addEventListener('DOMContentLoaded', initializeAdvancedFields);
- } else {
- initializeAdvancedFields();
- }
-
- document.body.addEventListener('htmx:afterSwap', function(event) {
- if (event.detail.target.id === 'service-form' || event.detail.target.closest('.crd-form')) {
- setTimeout(initializeAdvancedFields, 100);
- }
- });
-})();
diff --git a/src/servala/static/js/bootstrap-tabs.js b/src/servala/static/js/bootstrap-tabs.js
new file mode 100644
index 0000000..d382475
--- /dev/null
+++ b/src/servala/static/js/bootstrap-tabs.js
@@ -0,0 +1,30 @@
+// Bootstrap 5 automatically initializes tabs with data-bs-toggle="tab"
+// but we need to ensure they work after HTMX swaps
+(function() {
+ 'use strict';
+
+ const initBootstrapTabs = () => {
+ const customTabList = document.querySelectorAll('#myTab button[data-bs-toggle="tab"]');
+ customTabList.forEach(function(tabButton) {
+ new bootstrap.Tab(tabButton);
+ });
+
+ const expertTabList = document.querySelectorAll('#expertTab button[data-bs-toggle="tab"]');
+ expertTabList.forEach(function(tabButton) {
+ new bootstrap.Tab(tabButton);
+ });
+ }
+
+ if (document.readyState === 'loading') {
+ document.addEventListener('DOMContentLoaded', initBootstrapTabs);
+ } else {
+ initBootstrapTabs();
+ }
+
+ document.addEventListener('htmx:afterSwap', function(event) {
+ if (event.detail.target.id === 'service-form' ||
+ event.detail.target.classList.contains('crd-form')) {
+ initBootstrapTabs();
+ }
+ });
+})();
diff --git a/src/servala/static/js/expert-mode.js b/src/servala/static/js/expert-mode.js
new file mode 100644
index 0000000..2bfc2fa
--- /dev/null
+++ b/src/servala/static/js/expert-mode.js
@@ -0,0 +1,49 @@
+(function() {
+ 'use strict';
+
+ let isExpertMode = false;
+
+ function initExpertMode() {
+ const toggleButton = document.getElementById('expert-mode-toggle');
+ if (!toggleButton) return;
+
+ const customFormContainer = document.getElementById('custom-form-container');
+ const expertFormContainer = document.getElementById('expert-form-container');
+
+ if (!customFormContainer || !expertFormContainer) {
+ console.warn('Expert mode containers not found');
+ return;
+ }
+
+ toggleButton.addEventListener('click', function(e) {
+ e.preventDefault();
+ isExpertMode = !isExpertMode;
+
+ const activeFormInput = document.getElementById('active-form-input');
+
+ if (isExpertMode) {
+ customFormContainer.style.display = 'none';
+ expertFormContainer.style.display = 'block';
+ toggleButton.textContent = 'Show Simplified Form';
+ if (activeFormInput) activeFormInput.value = 'expert';
+ } else {
+ customFormContainer.style.display = 'block';
+ expertFormContainer.style.display = 'none';
+ toggleButton.textContent = 'Show Expert Mode';
+ if (activeFormInput) activeFormInput.value = 'custom';
+ }
+ });
+ }
+
+ if (document.readyState === 'loading') {
+ document.addEventListener('DOMContentLoaded', initExpertMode);
+ } else {
+ initExpertMode();
+ }
+
+ document.addEventListener('htmx:afterSwap', function(event) {
+ if (event.detail.target.id === 'service-form' || event.detail.target.classList.contains('crd-form')) {
+ initExpertMode();
+ }
+ });
+})();
diff --git a/src/servala/static/js/fqdn.js b/src/servala/static/js/fqdn.js
index a92071d..ec70dad 100644
--- a/src/servala/static/js/fqdn.js
+++ b/src/servala/static/js/fqdn.js
@@ -1,7 +1,9 @@
-const initializeFqdnGeneration = () => {
- const nameField = document.querySelector('input#id_name');
- const fqdnField = document.querySelector('label[for="id_spec.parameters.service.fqdn"] + div input.array-item-input');
+const initializeFqdnGeneration = (prefix) => {
+ const nameField = document.querySelector(`input#id_${prefix}-name`);
+ const fqdnFieldContainer = document.getElementById(`${prefix}-spec.parameters.service.fqdn_container`)
+ if (!nameField || !fqdnFieldContainer) return
+ const fqdnField = fqdnFieldContainer.querySelector('input.array-item-input');
if (nameField && fqdnField) {
const generateFqdn = (instanceName) => {
@@ -9,28 +11,23 @@ const initializeFqdnGeneration = () => {
return `${instanceName}-${fqdnConfig.namespace}.${fqdnConfig.wildcardDns}`;
}
- const newNameField = nameField.cloneNode(true);
- nameField.parentNode.replaceChild(newNameField, nameField);
- const newFqdnField = fqdnField.cloneNode(true);
- fqdnField.parentNode.replaceChild(newFqdnField, fqdnField);
-
- newNameField.addEventListener('input', function() {
- if (!newFqdnField.dataset.manuallyEdited) {
- newFqdnField.value = generateFqdn(this.value);
- const container = newFqdnField.closest('.dynamic-array-widget');
+ nameField.addEventListener('input', function() {
+ if (!fqdnField.dataset.manuallyEdited) {
+ fqdnField.value = generateFqdn(this.value);
+ const container = fqdnField.closest('.dynamic-array-widget');
if (container && window.updateHiddenInput) {
window.updateHiddenInput(container);
}
}
});
- newFqdnField.addEventListener('input', function() {
+ fqdnField.addEventListener('input', function() {
this.dataset.manuallyEdited = 'true';
});
- if (newNameField.value && !newFqdnField.value) {
- newFqdnField.value = generateFqdn(newNameField.value);
- const container = newFqdnField.closest('.dynamic-array-widget');
+ if (nameField.value && !fqdnField.value) {
+ fqdnField.value = generateFqdn(nameField.value);
+ const container = fqdnField.closest('.dynamic-array-widget');
if (container && window.updateHiddenInput) {
window.updateHiddenInput(container);
}
@@ -38,9 +35,10 @@ const initializeFqdnGeneration = () => {
}
}
-document.addEventListener('DOMContentLoaded', initializeFqdnGeneration);
+document.addEventListener('DOMContentLoaded', () => {initializeFqdnGeneration("custom"), initializeFqdnGeneration("expert")});
document.body.addEventListener('htmx:afterSwap', function(event) {
if (event.detail.target.id === 'service-form') {
- initializeFqdnGeneration();
+ initializeFqdnGeneration("custom");
+ initializeFqdnGeneration("expert");
}
});
diff --git a/src/tests/test_form_config.py b/src/tests/test_form_config.py
new file mode 100644
index 0000000..7188d61
--- /dev/null
+++ b/src/tests/test_form_config.py
@@ -0,0 +1,1086 @@
+from unittest.mock import Mock
+
+import jsonschema
+from django.core.validators import MaxValueValidator, MinValueValidator
+from django.db import models
+
+from servala.core.crd import generate_custom_form_class
+from servala.core.crd.forms import DEFAULT_FIELD_CONFIGS, MANDATORY_FIELDS
+from servala.core.forms import ServiceDefinitionAdminForm
+from servala.core.models import ControlPlaneCRD
+
+
+def test_custom_model_form_class_is_none_when_no_form_config():
+ crd = Mock(spec=ControlPlaneCRD)
+ service_def = Mock()
+ service_def.form_config = None
+ crd.service_definition = service_def
+ crd.django_model = Mock()
+
+ if not (
+ crd.django_model
+ and crd.service_definition
+ and crd.service_definition.form_config
+ and crd.service_definition.form_config.get("fieldsets")
+ ):
+ result = None
+ else:
+ result = generate_custom_form_class(
+ crd.service_definition.form_config, crd.django_model
+ )
+
+ assert result is None
+
+
+def test_custom_model_form_class_returns_class_when_form_config_exists():
+
+ crd = Mock(spec=ControlPlaneCRD)
+ service_def = Mock()
+ service_def.form_config = {
+ "fieldsets": [
+ {
+ "title": "General",
+ "fields": [
+ {
+ "type": "text",
+ "label": "Name",
+ "controlplane_field_mapping": "name",
+ "required": True,
+ }
+ ],
+ }
+ ]
+ }
+ crd.service_definition = service_def
+
+ class TestModel(models.Model):
+ name = models.CharField(max_length=100)
+
+ class Meta:
+ app_label = "test"
+
+ crd.django_model = TestModel
+
+ if not (
+ crd.django_model
+ and crd.service_definition
+ and crd.service_definition.form_config
+ and crd.service_definition.form_config.get("fieldsets")
+ ):
+ result = None
+ else:
+ result = generate_custom_form_class(
+ crd.service_definition.form_config, crd.django_model
+ )
+
+ assert result is not None
+ assert hasattr(result, "form_config")
+
+
+def test_form_config_schema_validates_minimal_config():
+ form = ServiceDefinitionAdminForm()
+ schema = form.form_config_schema
+
+ minimal_config = {
+ "fieldsets": [
+ {
+ "fields": [
+ {
+ "type": "text",
+ "label": "Service Name",
+ "controlplane_field_mapping": "spec.serviceName",
+ }
+ ]
+ }
+ ]
+ }
+
+ jsonschema.validate(instance=minimal_config, schema=schema)
+
+
+def test_form_config_schema_validates_config_with_null_integers():
+ form = ServiceDefinitionAdminForm()
+ schema = form.form_config_schema
+
+ config_with_nulls = {
+ "fieldsets": [
+ {
+ "fields": [
+ {
+ "type": "text",
+ "label": "Service Name",
+ "controlplane_field_mapping": "spec.serviceName",
+ "max_length": None,
+ "required": False,
+ },
+ {
+ "type": "textarea",
+ "label": "Description",
+ "controlplane_field_mapping": "spec.description",
+ "rows": None,
+ "max_length": None,
+ },
+ {
+ "type": "number",
+ "label": "Port",
+ "controlplane_field_mapping": "spec.port",
+ "min_value": None,
+ "max_value": None,
+ },
+ {
+ "type": "array",
+ "label": "Tags",
+ "controlplane_field_mapping": "spec.tags",
+ "min_values": None,
+ "max_values": None,
+ },
+ ]
+ }
+ ]
+ }
+
+ jsonschema.validate(instance=config_with_nulls, schema=schema)
+
+
+def test_form_config_schema_validates_full_config():
+ form = ServiceDefinitionAdminForm()
+ schema = form.form_config_schema
+
+ full_config = {
+ "fieldsets": [
+ {
+ "title": "Service Configuration",
+ "fields": [
+ {
+ "type": "text",
+ "label": "Service Name",
+ "controlplane_field_mapping": "spec.serviceName",
+ "help_text": "Enter a unique service name",
+ "required": True,
+ "max_length": 100,
+ },
+ {
+ "type": "email",
+ "label": "Admin Email",
+ "controlplane_field_mapping": "spec.adminEmail",
+ "help_text": "Contact email for service administrator",
+ "required": True,
+ "max_length": 255,
+ },
+ {
+ "type": "textarea",
+ "label": "Description",
+ "controlplane_field_mapping": "spec.description",
+ "help_text": "Describe the service purpose",
+ "required": False,
+ "rows": 5,
+ "max_length": 500,
+ },
+ {
+ "type": "number",
+ "label": "Port",
+ "controlplane_field_mapping": "spec.port",
+ "help_text": "Service port number",
+ "required": True,
+ "min_value": 1,
+ "max_value": 65535,
+ },
+ {
+ "type": "choice",
+ "label": "Environment",
+ "controlplane_field_mapping": "spec.environment",
+ "help_text": "Deployment environment",
+ "required": True,
+ "choices": [
+ ["dev", "Development"],
+ ["staging", "Staging"],
+ ["prod", "Production"],
+ ],
+ },
+ {
+ "type": "checkbox",
+ "label": "Enable Monitoring",
+ "controlplane_field_mapping": "spec.monitoring.enabled",
+ "help_text": "Enable service monitoring",
+ "required": False,
+ },
+ {
+ "type": "array",
+ "label": "Tags",
+ "controlplane_field_mapping": "spec.tags",
+ "help_text": "Service tags for organization",
+ "required": False,
+ "min_values": 0,
+ "max_values": 10,
+ },
+ ],
+ }
+ ]
+ }
+ jsonschema.validate(instance=full_config, schema=schema)
+
+
+def test_choice_field_uses_custom_choices_from_form_config():
+ """Test that choice fields use custom choices when provided in form_config"""
+
+ class TestModel(models.Model):
+ name = models.CharField(max_length=100)
+ environment = models.CharField(
+ max_length=20,
+ choices=[
+ ("dev", "Development"),
+ ("staging", "Staging"),
+ ("prod", "Production"),
+ ("test", "Testing"),
+ ],
+ )
+
+ class Meta:
+ app_label = "test"
+
+ form_config = {
+ "fieldsets": [
+ {
+ "title": "General",
+ "fields": [
+ {
+ "type": "text",
+ "label": "Name",
+ "controlplane_field_mapping": "name",
+ "required": True,
+ },
+ {
+ "type": "choice",
+ "label": "Environment",
+ "controlplane_field_mapping": "environment",
+ "required": True,
+ "choices": [["dev", "Development"], ["prod", "Production"]],
+ },
+ ],
+ }
+ ]
+ }
+
+ form_class = generate_custom_form_class(form_config, TestModel)
+ form = form_class()
+
+ environment_field = form.fields["environment"]
+ assert list(environment_field.choices) == [
+ ("dev", "Development"),
+ ("prod", "Production"),
+ ]
+
+ assert hasattr(environment_field, "_controlplane_choices")
+ assert len(environment_field._controlplane_choices) == 5 # 4 choices + empty choice
+
+
+def test_choice_field_uses_control_plane_choices_when_no_custom_choices():
+
+ class TestModel(models.Model):
+ name = models.CharField(max_length=100)
+ environment = models.CharField(
+ max_length=20,
+ choices=[
+ ("dev", "Development"),
+ ("staging", "Staging"),
+ ("prod", "Production"),
+ ],
+ )
+
+ class Meta:
+ app_label = "test"
+
+ form_config = {
+ "fieldsets": [
+ {
+ "title": "General",
+ "fields": [
+ {
+ "type": "text",
+ "label": "Name",
+ "controlplane_field_mapping": "name",
+ "required": True,
+ },
+ {
+ "type": "choice",
+ "label": "Environment",
+ "controlplane_field_mapping": "environment",
+ "required": True,
+ },
+ ],
+ }
+ ]
+ }
+
+ form_class = generate_custom_form_class(form_config, TestModel)
+ form = form_class()
+
+ environment_field = form.fields["environment"]
+ choices_list = list(environment_field.choices)
+ assert len(choices_list) == 4 # 3 choices + empty choice
+ assert ("dev", "Development") in choices_list
+
+
+def test_choice_field_validates_against_control_plane_choices():
+ class TestModel(models.Model):
+ name = models.CharField(max_length=100)
+ environment = models.CharField(
+ max_length=20,
+ choices=[
+ ("dev", "Development"),
+ ("staging", "Staging"),
+ ("prod", "Production"),
+ ],
+ )
+
+ class Meta:
+ app_label = "test"
+
+ form_config = {
+ "fieldsets": [
+ {
+ "title": "General",
+ "fields": [
+ {
+ "type": "text",
+ "label": "Name",
+ "controlplane_field_mapping": "name",
+ "required": True,
+ },
+ {
+ "type": "choice",
+ "label": "Environment",
+ "controlplane_field_mapping": "environment",
+ "required": True,
+ "choices": [["dev", "Development"], ["prod", "Production"]],
+ },
+ ],
+ }
+ ]
+ }
+
+ form_class = generate_custom_form_class(form_config, TestModel)
+
+ form = form_class(data={"name": "test-service", "environment": "dev"})
+ form.fields["context"].required = False # Skip context validation
+ assert form.is_valid(), f"Form should be valid but has errors: {form.errors}"
+
+ form = form_class(data={"name": "test-service", "environment": "prod"})
+ form.fields["context"].required = False # Skip context validation
+ assert form.is_valid(), f"Form should be valid but has errors: {form.errors}"
+
+ form = form_class(data={"name": "test-service", "environment": "invalid"})
+ form.fields["context"].required = False # Skip context validation
+ assert not form.is_valid()
+ assert "environment" in form.errors
+
+
+def test_admin_form_validates_choice_values_against_schema():
+
+ form = ServiceDefinitionAdminForm()
+ mock_crd = Mock()
+ mock_crd.resource_schema = {
+ "properties": {
+ "spec": {
+ "properties": {
+ "environment": {
+ "type": "string",
+ "enum": ["dev", "staging", "prod"],
+ }
+ }
+ }
+ }
+ }
+
+ valid_form_config = {
+ "fieldsets": [
+ {
+ "fields": [
+ {
+ "type": "text",
+ "label": "Name",
+ "controlplane_field_mapping": "name",
+ },
+ {
+ "type": "choice",
+ "label": "Environment",
+ "controlplane_field_mapping": "spec.environment",
+ "choices": [["dev", "Development"], ["prod", "Production"]],
+ },
+ ]
+ }
+ ]
+ }
+
+ spec_schema = mock_crd.resource_schema["properties"]["spec"]
+ errors = []
+
+ for field in valid_form_config["fieldsets"][0]["fields"]:
+ if field.get("type") == "choice":
+ form._validate_choice_field(
+ field, field["controlplane_field_mapping"], spec_schema, "spec", errors
+ )
+
+ assert len(errors) == 0, f"Expected no errors but got: {errors}"
+
+ invalid_form_config = {
+ "fieldsets": [
+ {
+ "fields": [
+ {
+ "type": "text",
+ "label": "Name",
+ "controlplane_field_mapping": "name",
+ },
+ {
+ "type": "choice",
+ "label": "Environment",
+ "controlplane_field_mapping": "spec.environment",
+ "choices": [
+ ["dev", "Development"],
+ ["invalid", "Invalid Environment"],
+ ],
+ },
+ ]
+ }
+ ]
+ }
+
+ errors = []
+
+ for field in invalid_form_config["fieldsets"][0]["fields"]:
+ if field.get("type") == "choice":
+ form._validate_choice_field(
+ field, field["controlplane_field_mapping"], spec_schema, "spec", errors
+ )
+
+ assert len(errors) > 0, "Expected validation errors but got none"
+ error_message = str(errors[0])
+ assert "invalid" in error_message.lower()
+ assert "Environment" in error_message
+
+
+def test_number_field_min_max_sets_widget_attributes():
+ class TestModel(models.Model):
+ name = models.CharField(max_length=100)
+ port = models.IntegerField()
+ replica_count = models.IntegerField()
+
+ class Meta:
+ app_label = "test"
+
+ form_config = {
+ "fieldsets": [
+ {
+ "title": "General",
+ "fields": [
+ {
+ "type": "text",
+ "label": "Name",
+ "controlplane_field_mapping": "name",
+ "required": True,
+ },
+ {
+ "type": "number",
+ "label": "Port",
+ "controlplane_field_mapping": "port",
+ "required": True,
+ "min_value": 1,
+ "max_value": 65535,
+ },
+ {
+ "type": "number",
+ "label": "Replicas",
+ "controlplane_field_mapping": "replica_count",
+ "required": True,
+ "min_value": 1,
+ "max_value": 10,
+ },
+ ],
+ }
+ ]
+ }
+
+ form_class = generate_custom_form_class(form_config, TestModel)
+ form = form_class()
+
+ port_field = form.fields["port"]
+ assert port_field.widget.attrs.get("min") == 1
+ assert port_field.widget.attrs.get("max") == 65535
+
+ replica_field = form.fields["replica_count"]
+ assert replica_field.widget.attrs.get("min") == 1
+ assert replica_field.widget.attrs.get("max") == 10
+
+ port_validators = port_field.validators
+ assert any(
+ isinstance(v, MinValueValidator) and v.limit_value == 1 for v in port_validators
+ )
+ assert any(
+ isinstance(v, MaxValueValidator) and v.limit_value == 65535
+ for v in port_validators
+ )
+
+
+def test_default_value_for_all_field_types():
+
+ class TestModel(models.Model):
+ name = models.CharField(max_length=100)
+ description = models.TextField()
+ port = models.IntegerField()
+ environment = models.CharField(
+ max_length=20,
+ choices=[
+ ("dev", "Development"),
+ ("staging", "Staging"),
+ ("prod", "Production"),
+ ],
+ )
+ monitoring_enabled = models.BooleanField()
+ tags = models.JSONField()
+
+ class Meta:
+ app_label = "test"
+
+ form_config = {
+ "fieldsets": [
+ {
+ "fields": [
+ {
+ "type": "text",
+ "label": "Name",
+ "controlplane_field_mapping": "name",
+ "default_value": "default-name",
+ },
+ {
+ "type": "textarea",
+ "label": "Description",
+ "controlplane_field_mapping": "description",
+ "default_value": "Default description text",
+ },
+ {
+ "type": "number",
+ "label": "Port",
+ "controlplane_field_mapping": "port",
+ "default_value": "8080",
+ },
+ {
+ "type": "choice",
+ "label": "Environment",
+ "controlplane_field_mapping": "environment",
+ "default_value": "dev",
+ },
+ {
+ "type": "checkbox",
+ "label": "Enable Monitoring",
+ "controlplane_field_mapping": "monitoring_enabled",
+ "default_value": "true",
+ },
+ {
+ "type": "array",
+ "label": "Tags",
+ "controlplane_field_mapping": "tags",
+ "default_value": "tag1,tag2,tag3",
+ },
+ ],
+ }
+ ]
+ }
+
+ form_class = generate_custom_form_class(form_config, TestModel)
+ form = form_class()
+
+ assert form.fields["name"].initial == "default-name"
+ assert form.fields["description"].initial == "Default description text"
+ assert form.fields["port"].initial == "8080"
+ assert form.fields["environment"].initial == "dev"
+ assert form.fields["monitoring_enabled"].initial == "true"
+ assert form.fields["tags"].initial == "tag1,tag2,tag3"
+
+
+def test_default_value_not_override_existing_instance():
+
+ class TestModel(models.Model):
+ name = models.CharField(max_length=100)
+ port = models.IntegerField()
+
+ class Meta:
+ app_label = "test"
+
+ form_config = {
+ "fieldsets": [
+ {
+ "fields": [
+ {
+ "type": "text",
+ "label": "Name",
+ "controlplane_field_mapping": "name",
+ "default_value": "default-name",
+ },
+ {
+ "type": "number",
+ "label": "Port",
+ "controlplane_field_mapping": "port",
+ "default_value": "8080",
+ },
+ ],
+ }
+ ]
+ }
+
+ instance = TestModel(name="existing-name", port=3000)
+ form_class = generate_custom_form_class(form_config, TestModel)
+ form = form_class(instance=instance)
+
+ assert form.initial["name"] == "existing-name"
+ assert form.initial["port"] == 3000
+
+
+def test_form_config_coerces_string_numbers_to_integers():
+ form = ServiceDefinitionAdminForm()
+ schema = form.form_config_schema
+
+ config_with_string_numbers = {
+ "fieldsets": [
+ {
+ "fields": [
+ {
+ "type": "text",
+ "label": "Service Name",
+ "controlplane_field_mapping": "spec.serviceName",
+ "max_length": "64", # String instead of integer
+ "required": True,
+ },
+ {
+ "type": "textarea",
+ "label": "Description",
+ "controlplane_field_mapping": "spec.description",
+ "rows": "5", # String instead of integer
+ "max_length": "500", # String instead of integer
+ },
+ {
+ "type": "number",
+ "label": "Port",
+ "controlplane_field_mapping": "spec.port",
+ "min_value": "1", # String instead of integer
+ "max_value": "65535", # String instead of integer
+ },
+ {
+ "type": "array",
+ "label": "Tags",
+ "controlplane_field_mapping": "spec.tags",
+ "min_values": "0", # String instead of integer
+ "max_values": "10", # String instead of integer
+ },
+ ]
+ }
+ ]
+ }
+
+ normalized_config = form._normalize_form_config_types(config_with_string_numbers)
+ fields = normalized_config["fieldsets"][0]["fields"]
+
+ assert fields[0]["max_length"] == 64
+ assert isinstance(fields[0]["max_length"], int)
+
+ assert fields[1]["rows"] == 5
+ assert isinstance(fields[1]["rows"], int)
+ assert fields[1]["max_length"] == 500
+ assert isinstance(fields[1]["max_length"], int)
+
+ assert fields[2]["min_value"] == 1
+ assert isinstance(fields[2]["min_value"], int)
+ assert fields[2]["max_value"] == 65535
+ assert isinstance(fields[2]["max_value"], int)
+
+ assert fields[3]["min_values"] == 0
+ assert isinstance(fields[3]["min_values"], int)
+ assert fields[3]["max_values"] == 10
+ assert isinstance(fields[3]["max_values"], int)
+
+ jsonschema.validate(instance=normalized_config, schema=schema)
+
+
+def test_form_config_handles_float_numbers():
+ form = ServiceDefinitionAdminForm()
+
+ config_with_floats = {
+ "fieldsets": [
+ {
+ "fields": [
+ {
+ "type": "number",
+ "label": "Price",
+ "controlplane_field_mapping": "spec.price",
+ "min_value": "0.01", # String float
+ "max_value": "999.99", # String float
+ },
+ ]
+ }
+ ]
+ }
+
+ normalized_config = form._normalize_form_config_types(config_with_floats)
+ field = normalized_config["fieldsets"][0]["fields"][0]
+
+ assert field["min_value"] == 0.01
+ assert isinstance(field["min_value"], float)
+ assert field["max_value"] == 999.99
+ assert isinstance(field["max_value"], float)
+
+
+def test_form_config_handles_empty_string_as_none():
+ form = ServiceDefinitionAdminForm()
+
+ config_with_empty_strings = {
+ "fieldsets": [
+ {
+ "fields": [
+ {
+ "type": "text",
+ "label": "Name",
+ "controlplane_field_mapping": "name",
+ "max_length": "", # Empty string
+ },
+ ]
+ }
+ ]
+ }
+
+ normalized_config = form._normalize_form_config_types(config_with_empty_strings)
+ field = normalized_config["fieldsets"][0]["fields"][0]
+ assert field["max_length"] is None
+
+
+def test_single_element_choices_are_normalized():
+ form = ServiceDefinitionAdminForm()
+ mock_crd = Mock()
+ mock_crd.resource_schema = {
+ "properties": {
+ "spec": {
+ "properties": {
+ "version": {
+ "type": "string",
+ "enum": ["6.2", "7.0", "7.2"],
+ }
+ }
+ }
+ }
+ }
+
+ config_with_single_choices = {
+ "fieldsets": [
+ {
+ "fields": [
+ {
+ "type": "text",
+ "label": "Name",
+ "controlplane_field_mapping": "name",
+ },
+ {
+ "type": "choice",
+ "label": "Version",
+ "controlplane_field_mapping": "spec.version",
+ "choices": [["6.2"]], # Single element - should be transformed
+ },
+ ]
+ }
+ ]
+ }
+
+ spec_schema = mock_crd.resource_schema["properties"]["spec"]
+ errors = []
+
+ for field in config_with_single_choices["fieldsets"][0]["fields"]:
+ if field.get("type") == "choice":
+ form._validate_choice_field(
+ field, field["controlplane_field_mapping"], spec_schema, "spec", errors
+ )
+
+ assert len(errors) == 0, f"Expected no errors but got: {errors}"
+ version_field = config_with_single_choices["fieldsets"][0]["fields"][1]
+ assert version_field["choices"] == [["6.2", "6.2"]]
+
+
+def test_two_element_choices_work_correctly():
+ form = ServiceDefinitionAdminForm()
+ mock_crd = Mock()
+ mock_crd.resource_schema = {
+ "properties": {
+ "spec": {
+ "properties": {
+ "version": {
+ "type": "string",
+ "enum": ["6.2", "7.0"],
+ }
+ }
+ }
+ }
+ }
+
+ config_with_proper_choices = {
+ "fieldsets": [
+ {
+ "fields": [
+ {
+ "type": "choice",
+ "label": "Version",
+ "controlplane_field_mapping": "spec.version",
+ "choices": [["6.2", "Version 6.2"], ["7.0", "Version 7.0"]],
+ },
+ ]
+ }
+ ]
+ }
+
+ spec_schema = mock_crd.resource_schema["properties"]["spec"]
+ errors = []
+
+ for field in config_with_proper_choices["fieldsets"][0]["fields"]:
+ if field.get("type") == "choice":
+ form._validate_choice_field(
+ field, field["controlplane_field_mapping"], spec_schema, "spec", errors
+ )
+
+ assert len(errors) == 0, f"Expected no errors but got: {errors}"
+ version_field = config_with_proper_choices["fieldsets"][0]["fields"][0]
+ assert version_field["choices"] == [["6.2", "Version 6.2"], ["7.0", "Version 7.0"]]
+
+
+def test_empty_choices_fail_validation():
+ form = ServiceDefinitionAdminForm()
+ config_with_empty_choice = {
+ "fieldsets": [
+ {
+ "fields": [
+ {
+ "type": "choice",
+ "label": "Version",
+ "controlplane_field_mapping": "spec.version",
+ "choices": [[]], # Empty choice - invalid
+ },
+ ]
+ }
+ ]
+ }
+
+ errors = []
+
+ for field in config_with_empty_choice["fieldsets"][0]["fields"]:
+ if field.get("type") == "choice":
+ form._validate_choice_field(
+ field, field["controlplane_field_mapping"], {}, "spec", errors
+ )
+
+ assert len(errors) > 0
+ assert "must have 1 or 2 elements" in str(errors[0])
+
+
+def test_three_plus_element_choices_fail_validation():
+ form = ServiceDefinitionAdminForm()
+ config_with_long_choice = {
+ "fieldsets": [
+ {
+ "fields": [
+ {
+ "type": "choice",
+ "label": "Version",
+ "controlplane_field_mapping": "spec.version",
+ "choices": [
+ ["6.2", "Version 6.2", "Extra"]
+ ], # 3 elements - invalid
+ },
+ ]
+ }
+ ]
+ }
+
+ errors = []
+
+ for field in config_with_long_choice["fieldsets"][0]["fields"]:
+ if field.get("type") == "choice":
+ form._validate_choice_field(
+ field, field["controlplane_field_mapping"], {}, "spec", errors
+ )
+
+ assert len(errors) > 0
+ assert "must have 1 or 2 elements" in str(errors[0])
+
+
+def test_field_with_default_config_only_needs_mapping():
+
+ class TestModel(models.Model):
+ name = models.CharField(max_length=100)
+
+ class Meta:
+ app_label = "test"
+
+ minimal_config = {
+ "fieldsets": [
+ {
+ "fields": [
+ {
+ "controlplane_field_mapping": "name",
+ },
+ ]
+ }
+ ]
+ }
+
+ form_class = generate_custom_form_class(minimal_config, TestModel)
+ form = form_class()
+
+ name_field = form.fields["name"]
+ assert name_field.label == DEFAULT_FIELD_CONFIGS["name"]["label"]
+ assert name_field.help_text == DEFAULT_FIELD_CONFIGS["name"]["help_text"]
+ assert name_field.required == DEFAULT_FIELD_CONFIGS["name"]["required"]
+
+
+def test_field_with_default_config_can_override_defaults():
+
+ class TestModel(models.Model):
+ name = models.CharField(max_length=100)
+
+ class Meta:
+ app_label = "test"
+
+ override_config = {
+ "fieldsets": [
+ {
+ "fields": [
+ {
+ "controlplane_field_mapping": "name",
+ "label": "Custom Name Label",
+ "required": False,
+ },
+ ]
+ }
+ ]
+ }
+
+ form_class = generate_custom_form_class(override_config, TestModel)
+ form = form_class()
+
+ name_field = form.fields["name"]
+ assert name_field.label == "Custom Name Label"
+ assert name_field.required is False
+ assert name_field.help_text == DEFAULT_FIELD_CONFIGS["name"]["help_text"]
+
+
+def test_admin_form_validates_mandatory_fields_present():
+
+ mock_crd = Mock()
+ mock_crd.resource_schema = {
+ "properties": {
+ "spec": {
+ "properties": {
+ "environment": {
+ "type": "string",
+ "enum": ["dev", "prod"],
+ }
+ }
+ }
+ }
+ }
+
+ config_without_name = {
+ "fieldsets": [
+ {
+ "fields": [
+ {
+ "type": "choice",
+ "label": "Environment",
+ "controlplane_field_mapping": "spec.environment",
+ "choices": [["dev", "Development"]],
+ },
+ ]
+ }
+ ]
+ }
+
+ errors = []
+ included_mappings = set()
+ for fieldset in config_without_name.get("fieldsets", []):
+ for field in fieldset.get("fields", []):
+ mapping = field.get("controlplane_field_mapping")
+ included_mappings.add(mapping)
+
+ for mandatory_field in MANDATORY_FIELDS:
+ if mandatory_field not in included_mappings:
+ errors.append(f"Required field '{mandatory_field}' must be included")
+
+ assert len(errors) > 0
+ assert "name" in str(errors[0]).lower()
+
+
+def test_admin_form_validates_fields_without_defaults_need_label_and_type():
+ config_with_incomplete_field = {
+ "fieldsets": [
+ {
+ "fields": [
+ {"controlplane_field_mapping": "name"}, # Has defaults - OK
+ {
+ "controlplane_field_mapping": "spec.unknown", # No defaults
+ # Missing label and type
+ },
+ ]
+ }
+ ]
+ }
+
+ errors = []
+
+ for fieldset in config_with_incomplete_field.get("fieldsets", []):
+ for field in fieldset.get("fields", []):
+ mapping = field.get("controlplane_field_mapping")
+
+ if mapping not in DEFAULT_FIELD_CONFIGS:
+ if not field.get("label"):
+ errors.append(
+ f"Field with mapping '{mapping}' must have a 'label' property"
+ )
+ if not field.get("type"):
+ errors.append(
+ f"Field with mapping '{mapping}' must have a 'type' property"
+ )
+
+ assert len(errors) == 2
+ assert any("label" in str(e) for e in errors)
+ assert any("type" in str(e) for e in errors)
+
+
+def test_empty_values_dont_override_default_configs():
+
+ class TestModel(models.Model):
+ name = models.CharField(max_length=100)
+
+ class Meta:
+ app_label = "test"
+
+ admin_form_config = {
+ "fieldsets": [
+ {
+ "fields": [
+ {
+ "controlplane_field_mapping": "name",
+ "type": "",
+ "label": "",
+ "help_text": None,
+ "max_length": None,
+ "required": False,
+ },
+ ]
+ }
+ ]
+ }
+
+ form_class = generate_custom_form_class(admin_form_config, TestModel)
+ form = form_class()
+
+ name_field = form.fields["name"]
+
+ assert name_field.label == DEFAULT_FIELD_CONFIGS["name"]["label"]
+ assert name_field.help_text == DEFAULT_FIELD_CONFIGS["name"]["help_text"]
+ assert name_field.max_length == DEFAULT_FIELD_CONFIGS["name"]["max_length"]
+
+ assert name_field.required is False # Was overridden by explicit False