def test_datetime_time_field(
        self,
        normalize_sdl,
        graphene_version,
        is_graphene_1_or_2,
    ):
        versions_1_x = {"1.1.2", "1.1.1", "1.1", "1.0.2", "1.0.1", "1.0"}
        if graphene_version in versions_1_x:
            with pytest.raises(pydantic2graphene.FieldNotSupported):
                pydantic2graphene.to_graphene(to_pydantic_class(datetime.time))
            return

        value = pydantic2graphene.to_graphene(to_pydantic_class(datetime.time))
        expected_value = '''
            type FakeGql {
              field: Time!
            }

            """
            The `Time` scalar type represents a Time value as specified by
            [iso8601](https://en.wikipedia.org/wiki/ISO_8601).
            """

            scalar Time
        '''
        if is_graphene_1_or_2:
            expected_value = """
                type FakeGql {
                    field: Time!
                }scalarTime
            """
        assert normalize_sdl(value) == normalize_sdl(expected_value)
Example #2
0
def test_input_usage(input_query_schema):
    MyModelGql = pydantic2graphene.to_graphene(MyModel)
    MyModelInputGql = pydantic2graphene.to_graphene(MyModel,
                                                    graphene.InputObjectType)

    schema = input_query_schema(MyModelGql,
                                MyModelInputGql(),
                                resolve_model=MyModel)

    query = """
    query {
        h1: hello (inp: {field1: 99.01}) {
            f1: field1
            f2: field2
        }

        h2: hello (inp: {field1: 109.01, field2: 101.1}) {
            field1
            field2
        }
    }
    """
    value = schema.execute(query).data
    expected_value = {
        "h1": {
            "f1": 99.01,
            "f2": 3.14159265359
        },
        "h2": {
            "field1": 109.01,
            "field2": 101.1
        },
    }

    assert value == expected_value
    def test_datetime_date_field(
        self,
        normalize_sdl,
        graphene_version,
        is_graphene_1_or_2,
    ):
        version_1_x = graphene_version.startswith("1.")
        version_2_0 = graphene_version == "2.0"
        if version_1_x or version_2_0:
            with pytest.raises(pydantic2graphene.FieldNotSupported):
                pydantic2graphene.to_graphene(to_pydantic_class(datetime.date))
            return

        value = pydantic2graphene.to_graphene(to_pydantic_class(datetime.date))
        expected_value = '''
            type FakeGql {
              field: Date!
            }

            """
            The `Date` scalar type represents a Date
            value as specified by
            [iso8601](https://en.wikipedia.org/wiki/ISO_8601).
            """
            scalar Date
        '''
        if is_graphene_1_or_2:
            expected_value = """
                scalarDatetypeFakeGql {
                    field: Date!
                }
            """
        assert normalize_sdl(value) == normalize_sdl(expected_value)
Example #4
0
    def test_pydantic_json_field(self, normalize_sdl):
        graphene_not_suported = graphene.__version__ in {
            "1.4.2",
            "1.4.1",
            "1.4",
            "1.3",
            "1.2",
            "1.1.3",
            "1.1.2",
            "1.1.1",
            "1.1",
            "1.0.2",
            "1.0.1",
            "1.0",
        }
        pydantic_not_supported = str(pydantic.VERSION)[:3] in {
            "1.2",
            "1.1",
            "1.0",
        }
        if graphene_not_suported or pydantic_not_supported:
            with pytest.raises(pydantic2graphene.FieldNotSupported):
                pydantic2graphene.to_graphene(to_pydantic_class(pydantic.Json))
            return

        value = pydantic2graphene.to_graphene(to_pydantic_class(pydantic.Json))
        expected_value = """
            type FakeGql {
                field: JSONString
            }

            scalar JSONString
        """
        assert normalize_sdl(value) == normalize_sdl(expected_value)
    def test_pydantic_json_field(
        self,
        normalize_sdl,
        graphene_version,
        is_graphene_1_or_2,
        pydantic_version,
    ):
        graphene_not_suported = graphene_version in {
            "1.4.2",
            "1.4.1",
            "1.4",
            "1.3",
            "1.2",
            "1.1.3",
            "1.1.2",
            "1.1.1",
            "1.1",
            "1.0.2",
            "1.0.1",
            "1.0",
        }
        pydantic_not_supported = pydantic_version[:3] in {
            "1.2",
            "1.1",
            "1.0",
        }
        if graphene_not_suported or pydantic_not_supported:
            with pytest.raises(pydantic2graphene.FieldNotSupported):
                pydantic2graphene.to_graphene(to_pydantic_class(pydantic.Json))
            return

        value = pydantic2graphene.to_graphene(to_pydantic_class(pydantic.Json))

        expected_value = '''
            type FakeGql {
              field: JSONString
            }

            """
            Allows use of a JSON String for input / output from the GraphQL
            schema.

            Use of this type is *not recommended* as you lose the benefits of
            having a defined, static schema
            (one of the key benefits of GraphQL).
            """

            scalar JSONString
        '''
        if is_graphene_1_or_2:
            expected_value = """
                type FakeGql {
                    field: JSONString
                }

                scalar JSONString
            """

        assert normalize_sdl(value) == normalize_sdl(expected_value)
Example #6
0
    def test_datetime_time_field(self, normalize_sdl):
        versions_1_x = {"1.1.2", "1.1.1", "1.1", "1.0.2", "1.0.1", "1.0"}
        if graphene.__version__ in versions_1_x:
            with pytest.raises(pydantic2graphene.FieldNotSupported):
                pydantic2graphene.to_graphene(to_pydantic_class(datetime.time))
            return

        value = pydantic2graphene.to_graphene(to_pydantic_class(datetime.time))
        expected_value = """
            type FakeGql {
                field: Time!
            }scalarTime
        """
        assert normalize_sdl(value) == normalize_sdl(expected_value)
Example #7
0
    def test_datetime_date_field(self, normalize_sdl):
        version_1_x = graphene.__version__.startswith("1.")
        version_2_0 = graphene.__version__ == "2.0"
        if version_1_x or version_2_0:
            with pytest.raises(pydantic2graphene.FieldNotSupported):
                pydantic2graphene.to_graphene(to_pydantic_class(datetime.date))
            return

        value = pydantic2graphene.to_graphene(to_pydantic_class(datetime.date))
        expected_value = """
            scalarDatetypeFakeGql {
                field: Date!
            }
        """
        assert normalize_sdl(value) == normalize_sdl(expected_value)
    def test_int_enum_field(self, normalize_sdl, is_graphene_1_or_2):
        class Enumer(enum.IntEnum):
            ONE = 1
            TWO = 2

        value = pydantic2graphene.to_graphene(to_pydantic_class(Enumer))
        expected_value = '''
            type FakeGql {
              field: Enumer!
            }

            """An enumeration."""
            enum Enumer {
              ONE
              TWO
            }
        '''
        if is_graphene_1_or_2:
            expected_value = """
                enum Enumer {
                    ONE
                    TWO
                }

                type FakeGql {
                    field: Enumer!
                }
            """

        assert normalize_sdl(value) == normalize_sdl(expected_value)
 def test_uuid_field(self, normalize_sdl):
     value = pydantic2graphene.to_graphene(to_pydantic_class(uuid.UUID))
     expected_value = """
         type FakeGql {
             field: String!
         }
     """
     assert normalize_sdl(value) == normalize_sdl(expected_value)
 def test_pydantic_conint_field(self, normalize_sdl):
     value = pydantic2graphene.to_graphene(
         to_pydantic_class(pydantic.conint()))
     expected_value = """
         type FakeGql {
             field: Int!
         }
     """
     assert normalize_sdl(value) == normalize_sdl(expected_value)
 def test_pydantic_positive_float_field(self, normalize_sdl):
     value = pydantic2graphene.to_graphene(
         to_pydantic_class(pydantic.PositiveFloat))
     expected_value = """
         type FakeGql {
             field: Float!
         }
     """
     assert normalize_sdl(value) == normalize_sdl(expected_value)
 def test_pydantic_ipv_any_network_field(self, normalize_sdl):
     value = pydantic2graphene.to_graphene(
         to_pydantic_class(pydantic.IPvAnyNetwork))
     expected_value = """
         type FakeGql {
             field: String!
         }
     """
     assert normalize_sdl(value) == normalize_sdl(expected_value)
 def test_pydantic_secret_str_field(self, normalize_sdl):
     value = pydantic2graphene.to_graphene(
         to_pydantic_class(pydantic.SecretStr))
     expected_value = """
         type FakeGql {
             field: String!
         }
     """
     assert normalize_sdl(value) == normalize_sdl(expected_value)
 def test_pydantic_redisdsn_field(self, normalize_sdl):
     value = pydantic2graphene.to_graphene(
         to_pydantic_class(pydantic.RedisDsn))
     expected_value = """
         type FakeGql {
             field: String!
         }
     """
     assert normalize_sdl(value) == normalize_sdl(expected_value)
 def test_pydantic_http_url_field(self, normalize_sdl):
     value = pydantic2graphene.to_graphene(
         to_pydantic_class(pydantic.HttpUrl))
     expected_value = """
         type FakeGql {
             field: String!
         }
     """
     assert normalize_sdl(value) == normalize_sdl(expected_value)
 def test_typing_pattern_field(self, normalize_sdl):
     value = pydantic2graphene.to_graphene(to_pydantic_class(
         typing.Pattern))
     expected_value = """
         type FakeGql {
             field: String!
         }
     """
     assert normalize_sdl(value) == normalize_sdl(expected_value)
 def test_optional_field(self, normalize_sdl):
     value = pydantic2graphene.to_graphene(
         to_pydantic_class(typing.Optional[int]))
     expected_value = """
         type FakeGql {
             field: Int
         }
     """
     assert normalize_sdl(value) == normalize_sdl(expected_value)
 def test_decimal_field(self, normalize_sdl):
     value = pydantic2graphene.to_graphene(
         to_pydantic_class(decimal.Decimal))
     expected_value = """
         type FakeGql {
             field: Float!
         }
     """
     assert normalize_sdl(value) == normalize_sdl(expected_value)
 def test_ipaddress_ipv6network_field(self, normalize_sdl):
     value = pydantic2graphene.to_graphene(
         to_pydantic_class(ipaddress.IPv6Network))
     expected_value = """
         type FakeGql {
             field: String!
         }
     """
     assert normalize_sdl(value) == normalize_sdl(expected_value)
 def test_pydantic_conlist_str_field(self, normalize_sdl):
     value = pydantic2graphene.to_graphene(
         to_pydantic_class(pydantic.conlist(str, min_items=1, max_items=4)))
     expected_value = """
         type FakeGql {
             field: [String!]!
         }
     """
     assert normalize_sdl(value) == normalize_sdl(expected_value)
Example #21
0
def test_schema_input_declaration(normalize_sdl):
    value = pydantic2graphene.to_graphene(MyModel, graphene.InputObjectType)
    expected_value = """
        input MyModelInputGql {
            field1: Float!
            field2: Float=3.14159265359
        }
    """
    assert normalize_sdl(value) == normalize_sdl(expected_value)
 def test_typing_sequence_field(self, normalize_sdl):
     value = pydantic2graphene.to_graphene(
         to_pydantic_class(typing.Sequence[str]))
     expected_value = """
         type FakeGql {
             field: [String!]!
         }
     """
     assert normalize_sdl(value) == normalize_sdl(expected_value)
Example #23
0
def test_schema_interface_declaration(normalize_sdl):
    value = pydantic2graphene.to_graphene(MyModel, graphene.Interface)
    expected_value = """
        interface MyModelInterfaceGql {
            field1: String!
            field2: String
        }
    """
    assert normalize_sdl(value) == normalize_sdl(expected_value)
 def test_pydantic_payment_card_number_field(self, normalize_sdl):
     value = pydantic2graphene.to_graphene(
         to_pydantic_class(pydantic.PaymentCardNumber))
     expected_value = """
         type FakeGql {
             field: String!
         }
     """
     assert normalize_sdl(value) == normalize_sdl(expected_value)