+ {% if not fieldset.hidden %}
+
+
+ {{ fieldset.title }}
+ {% if fieldset.has_mandatory %}* {% endif %}
+
+
+ {% endif %}
+ {% endfor %}
+
+
+ {% for fieldset in form.get_fieldsets %}
+
{% for field in fieldset.fields %}
{% with field=form|get_field:field %}{{ field.as_field_group }}{% endwith %}
{% endfor %}
@@ -36,113 +74,70 @@
{% endfor %}
{% endfor %}
- {% elif form %}
- {# Multiple fieldsets or auto-generated form - render with tabs #}
-
- {% for fieldset in form.get_fieldsets %}
- {% if not fieldset.hidden %}
-
-
- {{ fieldset.title }}
- {% if fieldset.has_mandatory %}* {% endif %}
-
-
- {% endif %}
- {% endfor %}
-
-
- {% for fieldset in form.get_fieldsets %}
-
- {% 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 %}
-
- {% endif %}
- {% endfor %}
-
- {% endfor %}
-
- {% endif %}
-
- {% if expert_form and not hide_expert_mode %}
-
{% endif %}
- {% if form %}
-
- {% endif %}
-
- {# browser form validation fails when there are fields missing/invalid that are hidden #}
-
+{% if expert_form and not hide_expert_mode %}
+
-
+{% endif %}
+{% if form %}
+
+{% endif %}
+
+ {# browser form validation fails when there are fields missing/invalid that are hidden #}
+
{% if form and not hide_expert_mode %}
diff --git a/src/servala/frontend/views/service.py b/src/servala/frontend/views/service.py
index c26194d..b9f7d56 100644
--- a/src/servala/frontend/views/service.py
+++ b/src/servala/frontend/views/service.py
@@ -14,6 +14,7 @@ from servala.core.models import (
ServiceOffering,
)
from servala.frontend.forms.service import (
+ ComputePlanSelectionForm,
ControlPlaneSelectForm,
ServiceFilterForm,
ServiceInstanceDeleteForm,
@@ -152,6 +153,13 @@ class ServiceOfferingDetailView(OrganizationViewMixin, HtmxViewMixin, DetailView
control_plane=self.selected_plane, service_offering=self.object
).first()
+ @cached_property
+ def plan_form(self):
+ data = self.request.POST if self.request.method == "POST" else None
+ return ComputePlanSelectionForm(
+ data=data, control_plane_crd=self.context_object, prefix="plans"
+ )
+
def get_instance_form_kwargs(self, ignore_data=False):
return {
"initial": {
@@ -205,6 +213,7 @@ class ServiceOfferingDetailView(OrganizationViewMixin, HtmxViewMixin, DetailView
context["select_form"] = self.select_form
context["has_control_planes"] = self.planes.exists()
context["selected_plane"] = self.selected_plane
+ context["context_object"] = self.context_object
context["hide_expert_mode"] = self.hide_expert_mode
if self.request.method == "POST":
if self.is_custom_form:
@@ -222,6 +231,17 @@ class ServiceOfferingDetailView(OrganizationViewMixin, HtmxViewMixin, DetailView
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
+
+ if self.context_object:
+ context["plan_form"] = self.plan_form
+ context["has_available_plans"] = self.plan_form.fields[
+ "compute_plan_assignment"
+ ].queryset.exists()
+ if self.context_object.control_plane.storage_plan_price_per_gib:
+ context["storage_plan"] = {
+ "price_per_gib": self.context_object.control_plane.storage_plan_price_per_gib,
+ }
+
return context
def post(self, request, *args, **kwargs):
@@ -232,6 +252,9 @@ class ServiceOfferingDetailView(OrganizationViewMixin, HtmxViewMixin, DetailView
context["form_error"] = True
return self.render_to_response(context)
+ if not self.plan_form.is_valid():
+ return self.render_to_response(context)
+
if self.is_custom_form:
form = self.get_custom_instance_form()
else:
@@ -245,7 +268,11 @@ class ServiceOfferingDetailView(OrganizationViewMixin, HtmxViewMixin, DetailView
)
return self.render_to_response(context)
- if form.is_valid():
+ if form.is_valid() and self.plan_form.is_valid():
+ compute_plan_assignment = self.plan_form.cleaned_data[
+ "compute_plan_assignment"
+ ]
+
try:
service_instance = ServiceInstance.create_instance(
organization=self.request.organization,
@@ -253,16 +280,22 @@ class ServiceOfferingDetailView(OrganizationViewMixin, HtmxViewMixin, DetailView
context=self.context_object,
created_by=request.user,
spec_data=form.get_nested_data().get("spec"),
+ compute_plan_assignment=compute_plan_assignment,
)
return redirect(service_instance.urls.base)
except ValidationError as e:
form.add_error(None, e.message or str(e))
except Exception as e:
error_message = self.organization.add_support_message(
- _(f"Error creating instance: {str(e)}.")
+ _("Error creating instance: {error}.").format(error=str(e))
)
form.add_error(None, error_message)
+ if self.is_custom_form:
+ context["custom_service_form"] = form
+ else:
+ context["service_form"] = form
+
return self.render_to_response(context)
@@ -332,6 +365,18 @@ class ServiceInstanceDetailView(
context["has_delete_permission"] = self.request.user.has_perm(
ServiceInstance.get_perm("delete"), self.object
)
+
+ if self.object.compute_plan_assignment:
+ context["compute_plan_assignment"] = self.object.compute_plan_assignment
+
+ if (
+ self.object.context
+ and self.object.context.control_plane.storage_plan_price_per_gib
+ ):
+ context["storage_plan"] = {
+ "price_per_gib": self.object.context.control_plane.storage_plan_price_per_gib,
+ }
+
return context
def get_nested_spec(self):
@@ -475,6 +520,17 @@ class ServiceInstanceUpdateView(
kwargs.pop("data", None)
return cls(**kwargs)
+ @cached_property
+ def plan_form(self):
+ data = self.request.POST if self.request.method == "POST" else None
+ initial = self.object.compute_plan_assignment if self.object else None
+ return ComputePlanSelectionForm(
+ data=data,
+ control_plane_crd=self.object.context if self.object else None,
+ prefix="plans",
+ initial={"compute_plan_assignment": initial} if initial else None,
+ )
+
@property
def is_custom_form(self):
# Note: "custom form" = user-friendly, subset of fields
@@ -489,7 +545,7 @@ class ServiceInstanceUpdateView(
else:
form = self.get_form()
- if form.is_valid():
+ if form.is_valid() and self.plan_form.is_valid():
return self.form_valid(form)
return self.form_invalid(form)
@@ -506,14 +562,29 @@ class ServiceInstanceUpdateView(
def get_context_data(self, **kwargs):
context = super().get_context_data(**kwargs)
context["hide_expert_mode"] = self.hide_expert_mode
+
+ # Check if a form was passed (e.g., from form_invalid)
+ form_from_kwargs = kwargs.get("form")
+
if self.request.method == "POST":
if self.is_custom_form:
- context["custom_form"] = self.get_custom_form()
+ # Use the form with errors if passed, otherwise create new
+ context["custom_form"] = form_from_kwargs or self.get_custom_form()
context["form"] = self.get_form(ignore_data=True)
else:
+ # Use the form with errors if passed, otherwise create new
+ context["form"] = form_from_kwargs or self.get_form()
context["custom_form"] = self.get_custom_form(ignore_data=True)
else:
context["custom_form"] = self.get_custom_form()
+
+ if self.object and self.object.context:
+ context["plan_form"] = self.plan_form
+ if self.object.context.control_plane.storage_plan_price_per_gib:
+ context["storage_plan"] = {
+ "price_per_gib": self.object.context.control_plane.storage_plan_price_per_gib,
+ }
+
return context
def _deep_merge(self, base, update):
@@ -533,7 +604,17 @@ class ServiceInstanceUpdateView(
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)
+ compute_plan_assignment = None
+ if self.plan_form.is_valid():
+ compute_plan_assignment = self.plan_form.cleaned_data.get(
+ "compute_plan_assignment"
+ )
+
+ self.object.update_spec(
+ spec_data=spec_data,
+ updated_by=self.request.user,
+ compute_plan_assignment=compute_plan_assignment,
+ )
messages.success(
self.request,
_("Service instance '{name}' updated successfully.").format(
@@ -546,7 +627,7 @@ class ServiceInstanceUpdateView(
return self.form_invalid(form)
except Exception as e:
error_message = self.organization.add_support_message(
- _(f"Error updating instance: {str(e)}.")
+ _("Error updating instance: {error}.").format(error=str(e))
)
form.add_error(None, error_message)
return self.form_invalid(form)
diff --git a/src/servala/static/css/plan-selection.css b/src/servala/static/css/plan-selection.css
new file mode 100644
index 0000000..8ce099c
--- /dev/null
+++ b/src/servala/static/css/plan-selection.css
@@ -0,0 +1,140 @@
+.plan-selection .plan-dropdown {
+ position: relative;
+}
+
+.plan-selection .plan-dropdown-toggle {
+ cursor: pointer;
+ transition: border-color 0.15s ease-in-out, box-shadow 0.15s ease-in-out;
+ border: 1px solid #dee2e6;
+ border-radius: 0.375rem;
+ background: #fff;
+}
+
+.plan-selection .plan-dropdown-toggle:hover {
+ border-color: #a1afdf;
+}
+
+.plan-selection .plan-dropdown-toggle:focus {
+ color: #607080;
+ background-color: #fff;
+ border-color: #a1afdf;
+ outline: 0;
+ box-shadow: 0 0 0 0.25rem rgba(67, 94, 190, 0.25);
+}
+
+.plan-selection .plan-dropdown-toggle[aria-expanded="true"] {
+ border-color: #a1afdf;
+ box-shadow: 0 0 0 0.25rem rgba(67, 94, 190, 0.25);
+ border-bottom-left-radius: 0;
+ border-bottom-right-radius: 0;
+ border-bottom-color: transparent;
+}
+
+.plan-selection .plan-dropdown-toggle .dropdown-arrow {
+ transition: transform 0.2s ease;
+}
+
+.plan-selection .plan-dropdown-toggle[aria-expanded="true"] .dropdown-arrow {
+ transform: rotate(180deg);
+}
+
+.plan-selection .plan-dropdown-menu {
+ position: absolute;
+ top: 100%;
+ left: 0;
+ right: 0;
+ z-index: 1000;
+ display: none;
+ margin-top: -1px;
+ background: #fff;
+ border: 1px solid #a1afdf;
+ border-top: none;
+ border-radius: 0 0 0.375rem 0.375rem;
+ box-shadow: 0 0.5rem 1rem rgba(0, 0, 0, 0.15);
+ max-height: 400px;
+ overflow-y: auto;
+}
+
+.plan-selection .plan-dropdown-menu.show {
+ display: block;
+}
+
+.plan-selection .plan-option {
+ padding: 0.75rem 1rem;
+ cursor: pointer;
+ border-bottom: 1px solid #f0f0f0;
+ transition: background-color 0.15s ease;
+}
+
+.plan-selection .plan-option:last-child {
+ border-bottom: none;
+}
+
+.plan-selection .plan-option:hover,
+.plan-selection .plan-option.focused {
+ background-color: #f8f9fa;
+}
+
+.plan-selection .plan-option.selected {
+ background-color: #f0f4ff;
+}
+
+.plan-selection .plan-option.selected.focused {
+ background-color: #e0e8ff;
+}
+
+.plan-selection .plan-content {
+ padding: 0.75rem 1rem;
+}
+
+.plan-selection .plan-header h6 {
+ margin-bottom: 0.25rem;
+ font-size: 1rem;
+}
+
+.plan-selection .badge {
+ font-size: 0.75rem;
+ padding: 0.25em 0.5em;
+}
+
+.plan-selection .price-display {
+ font-size: 1.25rem;
+ font-weight: 600;
+}
+
+.plan-selection .plan-specs {
+ margin-top: 0.5rem;
+}
+
+.plan-selection .form-check-input {
+ position: absolute;
+ opacity: 0;
+ pointer-events: none;
+}
+
+.plan-selection .storage-card {
+ margin-top: 0.75rem;
+ border: 1px solid #dee2e6;
+ border-radius: 0.375rem;
+ background: #fff;
+}
+
+.plan-selection .storage-card .plan-content {
+ background-color: #f8f9fa;
+ border-radius: 0.375rem;
+}
+
+.plan-selection .storage-card .storage-icon {
+ width: 32px;
+ height: 32px;
+ display: flex;
+ align-items: center;
+ justify-content: center;
+ background: #e9ecef;
+ border-radius: 0.25rem;
+ color: #6c757d;
+}
+
+.plan-selection .storage-card .storage-icon .bi::before {
+ vertical-align: top;
+}
diff --git a/src/servala/static/js/fqdn.js b/src/servala/static/js/fqdn.js
index 0996bda..43805bf 100644
--- a/src/servala/static/js/fqdn.js
+++ b/src/servala/static/js/fqdn.js
@@ -9,7 +9,12 @@ const initializeFqdnGeneration = (prefix) => {
let isArrayField = true;
if (fqdnFieldContainer) {
- let fqdnField = fqdnFieldContainer.querySelector('input.array-item-input');
+ fqdnField = fqdnFieldContainer.querySelector("input.array-item-input")
+ if (!fqdnField) {
+ // We retry, as there is a field meant to be here, but not rendered yet
+ setTimeout(() => {initializeFqdnGeneration(prefix)}, 200)
+ return
+ }
} else {
fqdnField = document.getElementById(`id_${prefix}-spec.parameters.service.fqdn`);
isArrayField = false;
@@ -53,10 +58,14 @@ const initializeFqdnGeneration = (prefix) => {
}
}
-document.addEventListener('DOMContentLoaded', () => {initializeFqdnGeneration("custom"), initializeFqdnGeneration("expert")});
-document.body.addEventListener('htmx:afterSwap', function(event) {
- if (event.detail.target.id === 'service-form') {
- initializeFqdnGeneration("custom");
- initializeFqdnGeneration("expert");
- }
+const runFqdnInit = () => {
+ initializeFqdnGeneration("custom");
+ initializeFqdnGeneration("expert");
+}
+
+document.addEventListener('DOMContentLoaded', () => {
+ runFqdnInit()
+});
+document.body.addEventListener('htmx:afterSwap', function(event) {
+ if (event.detail.target.id === 'service-form') runFqdnInit()
});
diff --git a/src/servala/static/js/plan-selection.js b/src/servala/static/js/plan-selection.js
new file mode 100644
index 0000000..4b4c014
--- /dev/null
+++ b/src/servala/static/js/plan-selection.js
@@ -0,0 +1,244 @@
+/**
+ * Plan Selection Dropdown
+ * A custom dropdown component for selecting compute plans with keyboard navigation.
+ */
+(function() {
+ function initPlanSelection(container) {
+ const planDropdownToggle = container.querySelector('#plan-dropdown-toggle');
+ const planDropdownMenu = container.querySelector('#plan-dropdown-menu');
+ const planOptions = Array.from(container.querySelectorAll('.plan-option'));
+ const radioInputName = container.dataset.radioName;
+ const radioInputs = container.querySelectorAll('input[name="' + radioInputName + '"]');
+ let focusedIndex = -1;
+
+ if (!planDropdownToggle || planOptions.length === 0) {
+ return;
+ }
+
+ // Update the display in the toggle button based on selected plan
+ function updateSelectedDisplay(data) {
+ const nameEl = container.querySelector('#selected-plan-name');
+ const priceEl = container.querySelector('#selected-plan-price');
+ const unitEl = container.querySelector('#selected-plan-unit');
+ const cpuEl = container.querySelector('#selected-plan-cpu');
+ const memoryEl = container.querySelector('#selected-plan-memory');
+ const slaBadge = container.querySelector('#selected-plan-sla');
+
+ if (nameEl) nameEl.textContent = data.planName;
+ if (priceEl) priceEl.textContent = 'CHF ' + data.planPrice;
+ if (unitEl) unitEl.textContent = data.planUnit;
+ if (cpuEl) cpuEl.textContent = data.cpuLimits;
+ if (memoryEl) memoryEl.textContent = data.memoryLimits;
+
+ if (slaBadge) {
+ slaBadge.textContent = data.planSlaDisplay;
+ slaBadge.className = 'badge bg-' + (data.planSla === 'guaranteed' ? 'success' : 'secondary');
+ }
+ }
+
+ // Update CPU/memory fields in the form
+ function updateFormFields(data) {
+ const cpuLimit = document.querySelector('input[name="expert-spec.parameters.size.cpu"]');
+ const memoryLimit = document.querySelector('input[name="expert-spec.parameters.size.memory"]');
+ const cpuRequest = document.querySelector('input[name="expert-spec.parameters.size.requests.cpu"]');
+ const memoryRequest = document.querySelector('input[name="expert-spec.parameters.size.requests.memory"]');
+
+ if (cpuLimit) cpuLimit.value = data.cpuLimits;
+ if (memoryLimit) memoryLimit.value = data.memoryLimits;
+ if (cpuRequest) cpuRequest.value = data.cpuRequests;
+ if (memoryRequest) memoryRequest.value = data.memoryRequests;
+ }
+
+ // Select a plan by value
+ function selectPlan(value) {
+ // Update the hidden radio input
+ radioInputs.forEach(radio => {
+ radio.checked = (radio.value === value);
+ });
+
+ // Update visual selection
+ planOptions.forEach(option => {
+ option.classList.toggle('selected', option.dataset.value === value);
+ });
+
+ // Find selected option and update display
+ const selectedOption = container.querySelector('.plan-option[data-value="' + value + '"]');
+ if (selectedOption) {
+ const data = {
+ planName: selectedOption.dataset.planName,
+ planSla: selectedOption.dataset.planSla,
+ planSlaDisplay: selectedOption.dataset.planSlaDisplay,
+ planPrice: selectedOption.dataset.planPrice,
+ planUnit: selectedOption.dataset.planUnit,
+ cpuLimits: selectedOption.dataset.cpuLimits,
+ memoryLimits: selectedOption.dataset.memoryLimits,
+ cpuRequests: selectedOption.dataset.cpuRequests,
+ memoryRequests: selectedOption.dataset.memoryRequests
+ };
+ updateSelectedDisplay(data);
+ updateFormFields(data);
+ }
+ }
+
+ // Update focused option visually
+ function updateFocusedOption(newIndex) {
+ planOptions.forEach(opt => opt.classList.remove('focused'));
+ if (newIndex >= 0 && newIndex < planOptions.length) {
+ focusedIndex = newIndex;
+ planOptions[focusedIndex].classList.add('focused');
+ // Scroll into view if needed
+ planOptions[focusedIndex].scrollIntoView({ block: 'nearest' });
+ }
+ }
+
+ // Get index of currently selected option
+ function getSelectedIndex() {
+ return planOptions.findIndex(opt => opt.classList.contains('selected'));
+ }
+
+ // Open dropdown
+ function openDropdown() {
+ planDropdownToggle.setAttribute('aria-expanded', 'true');
+ planDropdownMenu.classList.add('show');
+ // Set focus to selected option or first option
+ const selectedIdx = getSelectedIndex();
+ updateFocusedOption(selectedIdx >= 0 ? selectedIdx : 0);
+ }
+
+ // Close dropdown
+ function closeDropdown() {
+ planDropdownToggle.setAttribute('aria-expanded', 'false');
+ planDropdownMenu.classList.remove('show');
+ planOptions.forEach(opt => opt.classList.remove('focused'));
+ focusedIndex = -1;
+ }
+
+ // Check if dropdown is open
+ function isOpen() {
+ return planDropdownToggle.getAttribute('aria-expanded') === 'true';
+ }
+
+ // Toggle dropdown visibility
+ function toggleDropdown() {
+ if (isOpen()) {
+ closeDropdown();
+ } else {
+ openDropdown();
+ }
+ }
+
+ // Event listeners
+ planDropdownToggle.addEventListener('click', toggleDropdown);
+ planDropdownToggle.addEventListener('keydown', function(e) {
+ if (e.key === 'Enter' || e.key === ' ') {
+ e.preventDefault();
+ if (isOpen() && focusedIndex >= 0) {
+ selectPlan(planOptions[focusedIndex].dataset.value);
+ closeDropdown();
+ } else {
+ toggleDropdown();
+ }
+ } else if (e.key === 'Escape') {
+ closeDropdown();
+ } else if (e.key === 'ArrowDown') {
+ e.preventDefault();
+ if (!isOpen()) {
+ openDropdown();
+ } else {
+ const newIndex = focusedIndex < planOptions.length - 1 ? focusedIndex + 1 : 0;
+ updateFocusedOption(newIndex);
+ }
+ } else if (e.key === 'ArrowUp') {
+ e.preventDefault();
+ if (!isOpen()) {
+ openDropdown();
+ } else {
+ const newIndex = focusedIndex > 0 ? focusedIndex - 1 : planOptions.length - 1;
+ updateFocusedOption(newIndex);
+ }
+ }
+ });
+
+ planOptions.forEach((option, index) => {
+ option.addEventListener('click', function() {
+ selectPlan(this.dataset.value);
+ closeDropdown();
+ planDropdownToggle.focus();
+ });
+ option.addEventListener('mouseenter', function() {
+ updateFocusedOption(index);
+ });
+ });
+
+ // Close dropdown when clicking outside
+ document.addEventListener('click', function(e) {
+ if (!planDropdownToggle.contains(e.target) && !planDropdownMenu.contains(e.target)) {
+ closeDropdown();
+ }
+ });
+
+ // Initialize with currently checked radio
+ const checkedRadio = container.querySelector('input[name="' + radioInputName + '"]:checked');
+ if (checkedRadio) {
+ selectPlan(checkedRadio.value);
+ }
+ }
+
+ function initStorageCostCalculator(container) {
+ const pricePerGiB = parseFloat(container.dataset.storagePricePerGib) || 0;
+ const perHourText = container.dataset.perHourText || 'per hour';
+
+ if (pricePerGiB === 0) {
+ return;
+ }
+
+ function setup() {
+ const diskInput = document.getElementById('id_custom-spec.parameters.size.disk');
+ if (diskInput && !diskInput.dataset.storageListenerAttached) {
+ diskInput.dataset.storageListenerAttached = 'true';
+ diskInput.addEventListener('input', function() {
+ const sizeGiB = parseFloat(this.value) || 0;
+ const totalCost = (sizeGiB * pricePerGiB).toFixed(2);
+ const display = document.getElementById('storage-cost-display');
+ if (display && sizeGiB > 0) {
+ display.innerHTML = '
' + sizeGiB + ' GiB × CHF ' + pricePerGiB + ' =
CHF ' + totalCost + ' ' + perHourText;
+ } else if (display) {
+ display.textContent = '';
+ }
+ });
+
+ // Trigger initial calculation if disk field has a value
+ if (diskInput.value) {
+ diskInput.dispatchEvent(new Event('input'));
+ }
+ }
+ }
+
+ // Try to setup immediately (in case form is already loaded)
+ setup();
+
+ // Also setup after HTMX swaps the form in
+ document.body.addEventListener('htmx:afterSwap', function(event) {
+ if (event.detail.target.id === 'service-form' || event.detail.target.id === 'control-plane-info') {
+ setup();
+ }
+ });
+ }
+
+ // Initialize all plan selection components on the page
+ function init() {
+ document.querySelectorAll('.plan-selection').forEach(function(container) {
+ if (container.dataset.radioName) {
+ initPlanSelection(container);
+ initStorageCostCalculator(container);
+ }
+ });
+ }
+
+ // Run on DOM ready
+ if (document.readyState === 'loading') {
+ document.addEventListener('DOMContentLoaded', init);
+ } else {
+ init();
+ }
+})();
diff --git a/src/tests/test_compute_plans.py b/src/tests/test_compute_plans.py
new file mode 100644
index 0000000..0317229
--- /dev/null
+++ b/src/tests/test_compute_plans.py
@@ -0,0 +1,199 @@
+from unittest.mock import Mock
+
+import pytest
+
+from servala.core.models import (
+ ComputePlan,
+ ComputePlanAssignment,
+ ServiceInstance,
+)
+
+
+@pytest.mark.django_db
+def test_create_compute_plan():
+ plan = ComputePlan.objects.create(
+ name="Small",
+ description="Small resource plan",
+ memory_requests="512Mi",
+ memory_limits="1Gi",
+ cpu_requests="100m",
+ cpu_limits="500m",
+ is_active=True,
+ )
+
+ assert plan.name == "Small"
+ assert plan.memory_requests == "512Mi"
+ assert plan.memory_limits == "1Gi"
+ assert plan.cpu_requests == "100m"
+ assert plan.cpu_limits == "500m"
+ assert plan.is_active is True
+
+
+@pytest.mark.django_db
+def test_compute_plan_str():
+ plan = ComputePlan.objects.create(
+ name="Medium",
+ memory_requests="1Gi",
+ memory_limits="2Gi",
+ cpu_requests="500m",
+ cpu_limits="1000m",
+ )
+ assert str(plan) == "Medium"
+
+
+@pytest.mark.django_db
+def test_get_resource_summary():
+ plan = ComputePlan.objects.create(
+ name="Large",
+ memory_requests="2Gi",
+ memory_limits="4Gi",
+ cpu_requests="1000m",
+ cpu_limits="2000m",
+ )
+ summary = plan.get_resource_summary()
+ assert summary == "2000m vCPU, 4Gi RAM"
+
+
+def test_apply_compute_plan_to_spec():
+ compute_plan = Mock()
+ compute_plan.memory_requests = "512Mi"
+ compute_plan.memory_limits = "1Gi"
+ compute_plan.cpu_requests = "100m"
+ compute_plan.cpu_limits = "500m"
+
+ compute_plan_assignment = Mock()
+ compute_plan_assignment.compute_plan = compute_plan
+ compute_plan_assignment.sla = "besteffort"
+
+ spec_data = {"parameters": {}}
+
+ result = ServiceInstance._apply_compute_plan_to_spec(
+ spec_data, compute_plan_assignment
+ )
+
+ assert result["parameters"]["size"]["memory"] == "1Gi"
+ assert result["parameters"]["size"]["cpu"] == "500m"
+ assert result["parameters"]["size"]["requests"]["memory"] == "512Mi"
+ assert result["parameters"]["size"]["requests"]["cpu"] == "100m"
+
+ assert result["parameters"]["service"]["serviceLevel"] == "besteffort"
+
+
+def test_apply_compute_plan_preserves_existing_spec():
+ compute_plan = Mock()
+ compute_plan.memory_requests = "512Mi"
+ compute_plan.memory_limits = "1Gi"
+ compute_plan.cpu_requests = "100m"
+ compute_plan.cpu_limits = "500m"
+
+ compute_plan_assignment = Mock()
+ compute_plan_assignment.compute_plan = compute_plan
+ compute_plan_assignment.sla = "guaranteed"
+
+ spec_data = {
+ "parameters": {
+ "custom_field": "custom_value",
+ "service": {"existingField": "value"},
+ }
+ }
+
+ result = ServiceInstance._apply_compute_plan_to_spec(
+ spec_data, compute_plan_assignment
+ )
+
+ assert result["parameters"]["custom_field"] == "custom_value"
+ assert result["parameters"]["service"]["existingField"] == "value"
+
+ assert result["parameters"]["size"]["memory"] == "1Gi"
+ assert result["parameters"]["service"]["serviceLevel"] == "guaranteed"
+
+
+def test_apply_compute_plan_with_none():
+ spec_data = {"parameters": {}}
+ result = ServiceInstance._apply_compute_plan_to_spec(spec_data, None)
+
+ assert result == spec_data
+
+
+def test_build_billing_annotations_complete():
+ compute_plan_assignment = Mock()
+ compute_plan_assignment.odoo_product_id = "test-product-123"
+ compute_plan_assignment.odoo_unit_id = "test-unit-hour"
+
+ control_plane = Mock()
+ control_plane.storage_plan_odoo_product_id = "storage-product-id"
+ control_plane.storage_plan_odoo_unit_id = "storage-unit-id"
+
+ annotations = ServiceInstance._build_billing_annotations(
+ compute_plan_assignment, control_plane
+ )
+
+ assert annotations["servala.com/erp_product_id_resource"] == "test-product-123"
+ assert annotations["servala.com/erp_unit_id_resource"] == "test-unit-hour"
+
+ assert annotations["servala.com/erp_product_id_storage"] == "storage-product-id"
+ assert annotations["servala.com/erp_unit_id_storage"] == "storage-unit-id"
+
+
+def test_build_billing_annotations_no_compute_plan():
+ control_plane = Mock()
+ control_plane.storage_plan_odoo_product_id = "storage-product-id"
+ control_plane.storage_plan_odoo_unit_id = "storage-unit-id"
+
+ annotations = ServiceInstance._build_billing_annotations(None, control_plane)
+
+ assert "servala.com/erp_product_id_resource" not in annotations
+ assert "servala.com/erp_unit_id_resource" not in annotations
+ assert annotations["servala.com/erp_product_id_storage"] == "storage-product-id"
+ assert annotations["servala.com/erp_unit_id_storage"] == "storage-unit-id"
+
+
+def test_build_billing_annotations_no_storage_plan():
+ compute_plan_assignment = Mock()
+ compute_plan_assignment.odoo_product_id = "product-id"
+ compute_plan_assignment.odoo_unit_id = "unit-id"
+
+ control_plane = Mock()
+ control_plane.storage_plan_odoo_product_id = None
+ control_plane.storage_plan_odoo_unit_id = None
+
+ annotations = ServiceInstance._build_billing_annotations(
+ compute_plan_assignment, control_plane
+ )
+
+ assert annotations["servala.com/erp_product_id_resource"] == "product-id"
+ assert annotations["servala.com/erp_unit_id_resource"] == "unit-id"
+ assert "servala.com/erp_product_id_storage" not in annotations
+ assert "servala.com/erp_unit_id_storage" not in annotations
+
+
+def test_build_billing_annotations_empty():
+ control_plane = Mock()
+ control_plane.storage_plan_odoo_product_id = None
+ control_plane.storage_plan_odoo_unit_id = None
+
+ annotations = ServiceInstance._build_billing_annotations(None, control_plane)
+
+ assert annotations == {}
+
+
+@pytest.mark.django_db
+def test_hour_unit():
+ choices = dict(ComputePlanAssignment.BILLING_UNIT_CHOICES)
+ assert "hour" in choices
+ assert str(choices["hour"]) == "Hour"
+
+
+@pytest.mark.django_db
+def test_all_billing_units():
+ choices = dict(ComputePlanAssignment.BILLING_UNIT_CHOICES)
+
+ assert "hour" in choices
+ assert "day" in choices
+ assert "month" in choices
+ assert "year" in choices
+
+ assert str(choices["hour"]) == "Hour"
+ assert str(choices["day"]) == "Day"
+ assert "Month" in str(choices["month"])
+ assert str(choices["year"]) == "Year"