Esempio n. 1
0
        public void Enum_imports_are_generated()
        {
            var mapping = new TypeMapping();

            mapping.AddType(typeof(Enum1));
            mapping.AddType(typeof(Enum2));

            var generator = createGenerator(mapping);

            generator.WriteEnumImports("enums");

            TextAssert.ContainsLine("import { Enum1, Enum2 } from './enums'", generator.GetResult());
        }
Esempio n. 2
0
        public void Adding_type_to_mapping_adds_all_descenand_types_if_attribute_specified()
        {
            var mapping = new TypeMapping();

            mapping.AddType(typeof(BaseClass));

            CollectionAssert.AreEquivalent(
                new[] { typeof(BaseClass), typeof(Descendant1), typeof(Descendant2) },
                mapping.GetGeneratedTypes().Keys);
        }
        public void Ignored_properties_are_excluded_from_code_generation()
        {
            var mapping = new TypeMapping();

            mapping.AddType(typeof(SimpleModel));

            var generatedType = mapping.GetGeneratedTypes()[typeof(SimpleModel)];

            TextAssert.ContainsLine("prop1: string;", generatedType);
            TextAssert.DoesNotContainLine("prop2: string;", generatedType);
        }
Esempio n. 4
0
        public void Adding_type_to_mapping_recursively_adds_all_referenced_types()
        {
            var mapping = new TypeMapping();

            mapping.AddType(typeof(Model));

            CollectionAssert.AreEquivalent(
                new[] { typeof(Model), typeof(NestedModel) },
                mapping.GetGeneratedTypes().Keys);
            CollectionAssert.AreEquivalent(
                new[] { typeof(Enum1), typeof(Enum2) },
                mapping.GetEnums());
        }
        public void Test()
        {
            var t = typeof(TestCase);
            var nullabilityHandling = NullabilityHandling.JsonProperty;
            var mappingConfig       = new TypeMappingConfig(nullabilityHandling);
            var mapping             = new TypeMapping(config: mappingConfig);

            mapping.AddType(t);
            var converted = mapping.GetGeneratedTypes()[t];

            Assert.That(converted, Is.EqualTo(
                            @"export interface TestCase {
	requiredProp: string;
	nullableProp: string | null;
	optionalProp?: string;
	nullableOptionalProp?: string | null;
}
"));
        }
Esempio n. 6
0
        public void All_nested_types_are_written_to_module()
        {
            var mapping = new TypeMapping();

            mapping.AddType(typeof(Model));

            var generator = createGenerator(mapping);

            generator.WriteTypeDefinitions();

            var result = generator.GetResult();

            TextAssert.ContainsLine("export interface Model {", result);
            TextAssert.ContainsLine("export interface NestedModel {", result);

            CollectionAssert.AreEquivalent(
                new[] { typeof(Model), typeof(NestedModel) },
                mapping.GetGeneratedTypes().Keys);
            CollectionAssert.AreEquivalent(
                new[] { typeof(Enum1), typeof(Enum2) },
                mapping.GetEnums());
        }