karrio-server-graph 2025.5__py3-none-any.whl

karrio/server/graph/tests/test_rate_sheets.py

@@ -0,0 +1,354 @@
+import karrio.lib as lib
+from unittest.mock import ANY
+from karrio.server.graph.tests.base import GraphTestCase
+import karrio.server.providers.models as providers
+
+
+class TestRateSheets(GraphTestCase):
+    def setUp(self):
+        super().setUp()
+
+        # Create a test rate sheet
+        self.rate_sheet = providers.RateSheet.objects.create(
+            name="Test Rate Sheet",
+            carrier_name="ups",
+            slug="test_rate_sheet",
+            created_by=self.user,
+        )
+
+        # Create a test service
+        self.service = providers.ServiceLevel.objects.create(
+            service_name="UPS Standard",
+            service_code="ups_standard",
+            carrier_service_code="11",
+            currency="USD",
+            active=True,
+            zones=[
+                {
+                    "rate": 10.00,
+                    "label": "Zone 1",
+                    "cities": ["New York", "Los Angeles"],
+                }
+            ],
+            created_by=self.user,
+        )
+        self.rate_sheet.services.add(self.service)
+
+    def test_query_rate_sheets(self):
+        response = self.query(
+            """
+            query get_rate_sheets {
+              rate_sheets {
+                edges {
+                  node {
+                    id
+                    name
+                    carrier_name
+                    slug
+                    services {
+                      id
+                      service_name
+                      service_code
+                      carrier_service_code
+                      active
+                      currency
+                      zones {
+                        rate
+                        label
+                        cities
+                        postal_codes
+                        country_codes
+                      }
+                    }
+                  }
+                }
+              }
+            }
+            """,
+            operation_name="get_rate_sheets",
+        )
+        response_data = response.data
+
+        self.assertResponseNoErrors(response)
+        self.assertDictEqual(
+            lib.to_dict(response_data),
+            RATE_SHEETS_RESPONSE,
+        )
+
+    def test_create_rate_sheet(self):
+        response = self.query(
+            """
+            mutation create_rate_sheet($data: CreateRateSheetMutationInput!) {
+              create_rate_sheet(input: $data) {
+                rate_sheet {
+                  id
+                  name
+                  carrier_name
+                  services {
+                    id
+                    service_name
+                    service_code
+                    currency
+                    zones {
+                      rate
+                      label
+                      postal_codes
+                    }
+                  }
+                }
+              }
+            }
+            """,
+            operation_name="create_rate_sheet",
+            variables=CREATE_RATE_SHEET_DATA,
+        )
+        response_data = response.data
+
+        self.assertResponseNoErrors(response)
+        self.assertDictEqual(response_data, CREATE_RATE_SHEET_RESPONSE)
+
+    def test_update_rate_sheet(self):
+        response = self.query(
+            """
+            mutation update_rate_sheet($data: UpdateRateSheetMutationInput!) {
+              update_rate_sheet(input: $data) {
+                rate_sheet {
+                  id
+                  name
+                  services {
+                    id
+                    service_name
+                    zones {
+                      rate
+                      label
+                      country_codes
+                    }
+                  }
+                }
+              }
+            }
+            """,
+            operation_name="update_rate_sheet",
+            variables={
+                "data": {
+                    "id": self.rate_sheet.id,
+                    "name": "Updated Rate Sheet",
+                    "services": [
+                        {
+                            "id": self.service.id,
+                            "service_name": "Updated Service",
+                            "zones": [
+                                {
+                                    "rate": 20.0,
+                                    "label": "Updated Zone",
+                                    "country_codes": ["US", "CA"],
+                                }
+                            ],
+                        }
+                    ],
+                },
+            },
+        )
+        response_data = response.data
+
+        self.assertResponseNoErrors(response)
+        self.assertDictEqual(
+            lib.to_dict(response_data),
+            UPDATE_RATE_SHEET_RESPONSE,
+        )
+
+    def test_update_service_zone(self):
+        response = self.query(
+            """
+            mutation update_zone($data: UpdateServiceZoneMutationInput!) {
+              update_service_zone(input: $data) {
+                rate_sheet {
+                  id
+                  services {
+                    id
+                    zones {
+                      rate
+                      label
+                      country_codes
+                    }
+                  }
+                }
+              }
+            }
+            """,
+            operation_name="update_zone",
+            variables={
+                "data": {
+                    "id": self.rate_sheet.id,
+                    "service_id": self.service.id,
+                    **UPDATE_ZONE_DATA["data"],
+                },
+            },
+        )
+        response_data = response.data
+
+        self.assertResponseNoErrors(response)
+        self.assertDictEqual(
+            lib.to_dict(response_data),
+            UPDATE_ZONE_RESPONSE,
+        )
+
+
+RATE_SHEETS_RESPONSE = {
+    "data": {
+        "rate_sheets": {
+            "edges": [
+                {
+                    "node": {
+                        "carrier_name": "ups",
+                        "id": ANY,
+                        "name": "Test Rate Sheet",
+                        "services": [
+                            {
+                                "active": True,
+                                "carrier_service_code": "11",
+                                "currency": "USD",
+                                "id": ANY,
+                                "service_code": "ups_standard",
+                                "service_name": "UPS Standard",
+                                "zones": [
+                                    {
+                                        "cities": ["New York", "Los Angeles"],
+                                        "label": "Zone 1",
+                                        "rate": 10.0,
+                                    }
+                                ],
+                            }
+                        ],
+                        "slug": "test_rate_sheet",
+                    }
+                }
+            ]
+        }
+    }
+}
+
+CREATE_RATE_SHEET_DATA = {
+    "data": {
+        "name": "New Rate Sheet",
+        "carrier_name": "fedex",
+        "services": [
+            {
+                "service_name": "FedEx Ground",
+                "service_code": "fedex_ground",
+                "carrier_service_code": "FEDEX_GROUND",
+                "currency": "USD",
+                "zones": [
+                    {
+                        "rate": 15.0,
+                        "label": "Zone A",
+                        "postal_codes": ["12345", "67890"],
+                    }
+                ],
+            }
+        ],
+    }
+}
+
+CREATE_RATE_SHEET_RESPONSE = {
+    "data": {
+        "create_rate_sheet": {
+            "rate_sheet": {
+                "id": ANY,
+                "name": "New Rate Sheet",
+                "carrier_name": "fedex",
+                "services": [
+                    {
+                        "id": ANY,
+                        "service_name": "FedEx Ground",
+                        "service_code": "fedex_ground",
+                        "currency": "USD",
+                        "zones": [
+                            {
+                                "rate": 15.0,
+                                "label": "Zone A",
+                                "postal_codes": ["12345", "67890"],
+                            }
+                        ],
+                    }
+                ],
+            }
+        }
+    }
+}
+
+UPDATE_RATE_SHEET_DATA = {
+    "data": {
+        "name": "Updated Rate Sheet",
+        "services": [
+            {
+                "id": ANY,  # Will be replaced with actual service ID in test
+                "service_name": "Updated Service",
+                "zones": [
+                    {
+                        "rate": 20.0,
+                        "label": "Updated Zone",
+                        "country_codes": ["US", "CA"],
+                    }
+                ],
+            }
+        ],
+    }
+}
+
+UPDATE_RATE_SHEET_RESPONSE = {
+    "data": {
+        "update_rate_sheet": {
+            "rate_sheet": {
+                "id": ANY,
+                "name": "Updated Rate Sheet",
+                "services": [
+                    {
+                        "id": ANY,
+                        "service_name": "Updated Service",
+                        "zones": [
+                            {
+                                "country_codes": ["US", "CA"],
+                                "label": "Updated Zone",
+                                "rate": 20.0,
+                            }
+                        ],
+                    }
+                ],
+            }
+        }
+    }
+}
+
+UPDATE_ZONE_DATA = {
+    "data": {
+        "zone_index": 0,
+        "zone": {
+            "rate": 25.0,
+            "label": "Modified Zone",
+            "country_codes": ["MX"],
+        },
+    }
+}
+
+UPDATE_ZONE_RESPONSE = {
+    "data": {
+        "update_service_zone": {
+            "rate_sheet": {
+                "id": ANY,
+                "services": [
+                    {
+                        "id": ANY,
+                        "zones": [
+                            {
+                                "rate": 25.0,
+                                "label": "Modified Zone",
+                                "country_codes": ["MX"],
+                            }
+                        ],
+                    }
+                ],
+            }
+        }
+    }
+}

karrio/server/graph/tests/test_registration.py

@@ -0,0 +1,209 @@
+from unittest.mock import patch, MagicMock
+from karrio.server.graph.tests.base import GraphTestCase
+from django.contrib.auth import get_user_model
+
+User = get_user_model()
+
+
+class TestUserRegistration(GraphTestCase):
+
+    @patch("karrio.server.conf.settings.ALLOW_SIGNUP", True)
+    @patch("karrio.server.conf.settings.EMAIL_ENABLED", False)
+    def test_register_user_mutation(self):
+        """Test successful user registration"""
+        # Ensure user doesn't exist
+        User.objects.filter(email="newuser@example.com").delete()
+
+        response = self.query(
+            """
+            mutation register_user($data: RegisterUserMutationInput!) {
+              register_user(input: $data) {
+                user {
+                  email
+                  full_name
+                  is_active
+                }
+              }
+            }
+            """,
+            operation_name="register_user",
+            variables={
+                "data": {
+                    "email": "newuser@example.com",
+                    "full_name": "New Test User",
+                    "password1": "TestPassword123!",
+                    "password2": "TestPassword123!",
+                    "redirect_url": "http://example.com/email",
+                }
+            },
+        )
+
+        self.assertResponseNoErrors(response)
+        self.assertIsNotNone(response.data["data"]["register_user"]["user"])
+        self.assertEqual(
+            response.data["data"]["register_user"]["user"]["email"],
+            "newuser@example.com",
+        )
+        self.assertEqual(
+            response.data["data"]["register_user"]["user"]["full_name"], "New Test User"
+        )
+
+        # Verify user was created in database
+        user = User.objects.get(email="newuser@example.com")
+        self.assertEqual(user.full_name, "New Test User")
+
+    @patch("karrio.server.conf.settings.ALLOW_SIGNUP", True)
+    def test_register_user_password_mismatch(self):
+        """Test registration fails with mismatched passwords"""
+        response = self.query(
+            """
+            mutation register_user($data: RegisterUserMutationInput!) {
+              register_user(input: $data) {
+                user {
+                  email
+                }
+              }
+            }
+            """,
+            operation_name="register_user",
+            variables={
+                "data": {
+                    "email": "mismatch@example.com",
+                    "full_name": "Mismatch User",
+                    "password1": "TestPassword123!",
+                    "password2": "DifferentPassword123!",
+                    "redirect_url": "http://example.com/email",
+                }
+            },
+        )
+
+        # Should have errors
+        self.assertIsNotNone(response.data.get("errors"))
+        self.assertIn("password", str(response.data["errors"][0]))
+
+    @patch("karrio.server.conf.settings.ALLOW_SIGNUP", True)
+    def test_register_user_duplicate_email(self):
+        """Test registration fails with duplicate email"""
+        # First create a user
+        User.objects.create_user(
+            email="existing@example.com",
+            password="ExistingPass123!",
+            full_name="Existing User",
+        )
+
+        response = self.query(
+            """
+            mutation register_user($data: RegisterUserMutationInput!) {
+              register_user(input: $data) {
+                user {
+                  email
+                }
+              }
+            }
+            """,
+            operation_name="register_user",
+            variables={
+                "data": {
+                    "email": "existing@example.com",
+                    "full_name": "Duplicate User",
+                    "password1": "TestPassword123!",
+                    "password2": "TestPassword123!",
+                    "redirect_url": "http://example.com/email",
+                }
+            },
+        )
+
+        # Should have errors about duplicate email
+        self.assertIsNotNone(response.data.get("errors"))
+
+    @patch("karrio.server.conf.settings.ALLOW_SIGNUP", False)
+    def test_register_user_signup_disabled(self):
+        """Test registration fails when signup is disabled"""
+        response = self.query(
+            """
+            mutation register_user($data: RegisterUserMutationInput!) {
+              register_user(input: $data) {
+                user {
+                  email
+                }
+              }
+            }
+            """,
+            operation_name="register_user",
+            variables={
+                "data": {
+                    "email": "disabled@example.com",
+                    "full_name": "Disabled User",
+                    "password1": "TestPassword123!",
+                    "password2": "TestPassword123!",
+                    "redirect_url": "http://example.com/email",
+                }
+            },
+        )
+
+        # Should have errors about signup not allowed
+        self.assertIsNotNone(response.data.get("errors"))
+        self.assertIn("Signup is not allowed", str(response.data["errors"][0]))
+
+
+class TestPasswordReset(GraphTestCase):
+
+    def setUp(self):
+        super().setUp()
+        # Create a test user for password reset
+        self.reset_user = User.objects.create_user(
+            email="resetuser@example.com",
+            password="OldPassword123!",
+            full_name="Reset User",
+        )
+
+    @patch("django.core.mail.send_mail")
+    def test_request_password_reset(self, mock_send_mail):
+        """Test requesting a password reset"""
+        response = self.query(
+            """
+            mutation request_password_reset($data: RequestPasswordResetMutationInput!) {
+              request_password_reset(input: $data) {
+                email
+                redirect_url
+              }
+            }
+            """,
+            operation_name="request_password_reset",
+            variables={
+                "data": {
+                    "email": "resetuser@example.com",
+                    "redirect_url": "http://example.com/password/reset",
+                }
+            },
+        )
+
+        self.assertResponseNoErrors(response)
+        self.assertEqual(
+            response.data["data"]["request_password_reset"]["email"],
+            "resetuser@example.com",
+        )
+
+
+class TestEmailConfirmation(GraphTestCase):
+
+    @patch("karrio.server.graph.schemas.base.mutations.email_verification.verify_token")
+    def test_confirm_email(self, mock_verify):
+        """Test email confirmation"""
+        mock_verify.return_value = (True, None)
+
+        response = self.query(
+            """
+            mutation confirm_email($data: ConfirmEmailMutationInput!) {
+              confirm_email(input: $data) {
+                success
+              }
+            }
+            """,
+            operation_name="confirm_email",
+            variables={"data": {"token": "test-confirmation-token"}},
+        )
+
+        self.assertResponseNoErrors(response)
+        self.assertTrue(response.data["data"]["confirm_email"]["success"])
+        mock_verify.assert_called_once_with("test-confirmation-token")