public void DecorateClassGenerationTest()
        {
            var implDetails = new Dictionary<JsonSchema, SchemaImplementationDetails>();
            var decorator = new ArraySchemaDecorator();
            var internalClassProvider = new ObjectInternalClassProvider();
            var decl = new CodeTypeDeclaration();

            var schema = new MockSchema();
            schema.Name = "test";
            schema.SchemaDetails = new JsonSchema();
            schema.SchemaDetails.Type = JsonSchemaType.Array;
            schema.SchemaDetails.Items = new List<JsonSchema>();
            schema.SchemaDetails.Items.Clear();
            schema.SchemaDetails.Items.Add(
                new JsonSchema { Description = "Test", Id = "TestSchema", Type = JsonSchemaType.Object });
            implDetails.Add(schema.SchemaDetails, new SchemaImplementationDetails());
            implDetails.Add(schema.SchemaDetails.Items[0], new SchemaImplementationDetails());
            Assert.DoesNotThrow(() => decorator.DecorateClass(decl, schema, implDetails, internalClassProvider));

            Assert.That(decl.BaseTypes.Count, Is.EqualTo(1));
            Assert.That(decl.BaseTypes[0].BaseType, Is.StringStarting("List<"));

            // Subtype will only be created later on by the NestedClassGenerator,
            // and therefore cannot be tested here
        }
Exemple #2
0
        public void GenerateAllPropertiesTestEdgeCases()
        {
            var    implDetails           = new Dictionary <JsonSchema, SchemaImplementationDetails>();
            var    decorator             = new StandardPropertyDecorator();
            var    internalClassProvider = new ObjectInternalClassProvider();
            string name = "test";

            Assert.Throws(
                typeof(ArgumentNullException),
                () => decorator.GenerateAllProperties(name, null, implDetails, internalClassProvider));

            var schema = new MockSchema();

            schema.Name          = "test";
            schema.SchemaDetails = null;
            Assert.Throws(
                typeof(ArgumentNullException),
                () => decorator.GenerateAllProperties(name, schema.SchemaDetails, implDetails, internalClassProvider));


            schema.SchemaDetails            = new JsonSchema();
            schema.SchemaDetails.Properties = null;
            Assert.Throws(
                typeof(ArgumentNullException),
                () => decorator.GenerateAllProperties(null, schema.SchemaDetails, implDetails, internalClassProvider));
            var expectedEmpty = decorator.GenerateAllProperties(
                name, schema.SchemaDetails, implDetails, internalClassProvider);

            Assert.IsNotNull(expectedEmpty);
            Assert.AreEqual(0, expectedEmpty.Count);
        }
        public void GetCodeTypeTest()
        {
            var schema = new JsonSchema();
            var internalClassProvider = new ObjectInternalClassProvider();

            schema.Type = JsonSchemaType.String;
            CodeTypeReference result = SchemaDecoratorUtil.GetCodeType(schema, null, internalClassProvider);

            Assert.AreEqual(typeof(string).FullName, result.BaseType);

            schema.Type = JsonSchemaType.Integer;
            result      = SchemaDecoratorUtil.GetCodeType(schema, null, internalClassProvider);
            Assert.AreEqual(typeof(Nullable <>).FullName, result.BaseType);
            Assert.AreEqual(typeof(long).FullName, result.TypeArguments[0].BaseType);

            schema.Type = JsonSchemaType.Float;
            result      = SchemaDecoratorUtil.GetCodeType(schema, null, internalClassProvider);
            Assert.AreEqual(typeof(Nullable <>).FullName, result.BaseType);
            Assert.AreEqual(typeof(double).FullName, result.TypeArguments[0].BaseType);

            schema.Type = JsonSchemaType.Boolean;
            result      = SchemaDecoratorUtil.GetCodeType(schema, null, internalClassProvider);
            Assert.AreEqual(typeof(Nullable <>).FullName, result.BaseType);
            Assert.AreEqual(typeof(bool).FullName, result.TypeArguments[0].BaseType);
        }
        public void DecorateClassGenerationTest()
        {
            var implDetails           = new Dictionary <JsonSchema, SchemaImplementationDetails>();
            var decorator             = new ArraySchemaDecorator();
            var internalClassProvider = new ObjectInternalClassProvider();
            var decl = new CodeTypeDeclaration();

            var schema = new MockSchema();

            schema.Name                = "test";
            schema.SchemaDetails       = new JsonSchema();
            schema.SchemaDetails.Type  = JsonSchemaType.Array;
            schema.SchemaDetails.Items = new List <JsonSchema>();
            schema.SchemaDetails.Items.Clear();
            schema.SchemaDetails.Items.Add(
                new JsonSchema {
                Description = "Test", Id = "TestSchema", Type = JsonSchemaType.Object
            });
            implDetails.Add(schema.SchemaDetails, new SchemaImplementationDetails());
            implDetails.Add(schema.SchemaDetails.Items[0], new SchemaImplementationDetails());
            Assert.DoesNotThrow(() => decorator.DecorateClass(decl, schema, implDetails, internalClassProvider));

            Assert.That(decl.BaseTypes.Count, Is.EqualTo(1));
            Assert.That(decl.BaseTypes[0].BaseType, Is.EqualTo(typeof(List <>).FullName));

            // Subtype will only be created later on by the NestedClassGenerator,
            // and therefore cannot be tested here
        }
        public void DecorateClassTestEdgeCases()
        {
            var implDetails                 = new Dictionary <JsonSchema, SchemaImplementationDetails>();
            var decorator                   = new ArraySchemaDecorator();
            var internalClassProvider       = new ObjectInternalClassProvider();
            CodeTypeDeclaration declaration = null;

            var schema = new MockSchema();

            schema.Name          = "test";
            schema.SchemaDetails = null;
            Assert.Throws(
                typeof(ArgumentNullException),
                () => decorator.DecorateClass(new CodeTypeDeclaration(), schema, implDetails, internalClassProvider));

            schema.SchemaDetails      = new JsonSchema();
            schema.SchemaDetails.Type = JsonSchemaType.Float;
            Assert.DoesNotThrow(
                () =>
                decorator.DecorateClass(
                    declaration = new CodeTypeDeclaration(), schema, implDetails, internalClassProvider));
            Assert.That(declaration.BaseTypes.Count, Is.EqualTo(0));

            schema.SchemaDetails.Type  = JsonSchemaType.Array;
            schema.SchemaDetails.Items = new List <JsonSchema>();
            schema.SchemaDetails.Items.Add(new JsonSchema());
            schema.SchemaDetails.Items.Add(new JsonSchema());
            Assert.DoesNotThrow(
                () =>
                decorator.DecorateClass(
                    declaration = new CodeTypeDeclaration(), schema, implDetails, internalClassProvider));
            Assert.That(declaration.BaseTypes.Count, Is.EqualTo(0));
        }
        public void DecorateClassTest()
        {
            // Init required vars.
            var decorator   = new ResponseInterfaceDecorator();
            var declaration = new CodeTypeDeclaration();
            var schema      = new MockSchema {
                SchemaDetails = new JsonSchema()
            };
            var internalClassProvider = new ObjectInternalClassProvider();
            var implDetails           = new Dictionary <JsonSchema, SchemaImplementationDetails>();

            implDetails.Add(schema.SchemaDetails, new SchemaImplementationDetails());

            // Test edge cases.
            Assert.Throws(
                typeof(ArgumentNullException),
                () => decorator.DecorateClass(null, schema, implDetails, internalClassProvider));
            Assert.Throws(
                typeof(ArgumentNullException),
                () => decorator.DecorateClass(declaration, null, implDetails, internalClassProvider));
            Assert.Throws(
                typeof(ArgumentNullException),
                () => decorator.DecorateClass(declaration, schema, null, internalClassProvider));

            decorator.DecorateClass(declaration, schema, implDetails, internalClassProvider);
            Assert.AreEqual(0, declaration.BaseTypes.Count);
            Assert.AreEqual(0, declaration.Members.Count);

            // Test simple functionality.
            var details = new SchemaImplementationDetails {
                IsMethodResult = true
            };

            implDetails = new Dictionary <JsonSchema, SchemaImplementationDetails>
            {
                { schema.SchemaDetails, details }
            };

            decorator.DecorateClass(declaration, schema, implDetails, internalClassProvider);

            Assert.AreEqual(1, declaration.BaseTypes.Count);
            Assert.AreEqual(2, declaration.Members.Count); // 1 property with a field.

            // Test with already existing e-tag field.
            declaration = new CodeTypeDeclaration();
            declaration.Members.Add(new CodeMemberProperty()
            {
                Name = "ETag"
            });
            decorator.DecorateClass(declaration, schema, implDetails, internalClassProvider);

            Assert.AreEqual(1, declaration.BaseTypes.Count);
            Assert.AreEqual(1, declaration.Members.Count);
        }
        public void GetCodeTypeArgumentValidationTest()
        {
            var internalClassProvider = new ObjectInternalClassProvider();
            Assert.Throws(
                typeof(ArgumentNullException),
                () => SchemaDecoratorUtil.GetCodeType(null, null, internalClassProvider));
            var schema = new JsonSchema();
            Assert.Throws(typeof(ArgumentNullException), () => SchemaDecoratorUtil.GetCodeType(schema, null, null));

            Assert.Throws(
                typeof(NotSupportedException),
                () => SchemaDecoratorUtil.GetCodeType(schema, null, internalClassProvider));
        }
Exemple #8
0
        public void GenerateAllPropertiesTest()
        {
            var implDetails           = new Dictionary <JsonSchema, SchemaImplementationDetails>();
            var schema                = new MockSchema();
            var internalClassProvider = new ObjectInternalClassProvider();

            schema.SchemaDetails            = new JsonSchema();
            schema.SchemaDetails.Type       = JsonSchemaType.Object;
            schema.SchemaDetails.Properties = new Dictionary <string, JsonSchema>();
            implDetails.Add(schema.SchemaDetails, new SchemaImplementationDetails());
            string name = "test";

            foreach (var pair in StandardPropertyFieldDecoratorTest.NamesToType)
            {
                JsonSchema property = new JsonSchema();
                property.Type        = pair.Value;
                property.Id          = pair.Key;
                property.Description = StandardPropertyFieldDecoratorTest.NamesToDescription[pair.Key];
                schema.SchemaDetails.Properties.Add(pair.Key, property);
                implDetails.Add(property, new SchemaImplementationDetails());
            }

            var decorator = new StandardPropertyDecorator();
            IList <CodeMemberProperty> generatedProperties = decorator.GenerateAllProperties(
                name, schema.SchemaDetails, implDetails, internalClassProvider);

            Assert.NotNull(generatedProperties);
            Assert.AreEqual(StandardPropertyFieldDecoratorTest.NamesToType.Count, generatedProperties.Count);
            foreach (var field in generatedProperties)
            {
                Assert.That(
                    StandardPropertyFieldDecoratorTest.NamesToType.ContainsKey(field.Name.ToLower()),
                    "field name was not present in namesToType " + field.Name);
            }

            int item = 0;

            foreach (var pair in StandardPropertyFieldDecoratorTest.NamesToType)
            {
                var field = generatedProperties[item++];
                Assert.AreEqual(
                    pair.Key, field.Name.ToLower(),
                    string.Format("Name different for expected at index {0}", item - 1));
                Assert.AreEqual(
                    SchemaDecoratorUtil.GetCodeType(new JsonSchema {
                    Type = pair.Value
                }, null, internalClassProvider)
                    .BaseType, field.Type.BaseType);
            }
        }
        public void GetCodeTypeArgumentValidationTest()
        {
            var internalClassProvider = new ObjectInternalClassProvider();

            Assert.Throws(
                typeof(ArgumentNullException),
                () => SchemaDecoratorUtil.GetCodeType(null, null, internalClassProvider));
            var schema = new JsonSchema();

            Assert.Throws(typeof(ArgumentNullException), () => SchemaDecoratorUtil.GetCodeType(schema, null, null));

            Assert.Throws(
                typeof(NotSupportedException),
                () => SchemaDecoratorUtil.GetCodeType(schema, null, internalClassProvider));
        }
        public void GenerateAllPropertiesTest()
        {
            var implDetails = new Dictionary<JsonSchema, SchemaImplementationDetails>();
            var schema = new MockSchema();
            var internalClassProvider = new ObjectInternalClassProvider();
            schema.SchemaDetails = new JsonSchema();
            schema.SchemaDetails.Type = JsonSchemaType.Object;
            schema.SchemaDetails.Properties = new Dictionary<string, JsonSchema>();
            implDetails.Add(schema.SchemaDetails, new SchemaImplementationDetails());
            string name = "test";

            foreach (var pair in StandardPropertyFieldDecoratorTest.NamesToType)
            {
                JsonSchema property = new JsonSchema();
                property.Type = pair.Value;
                property.Id = pair.Key;
                property.Description = StandardPropertyFieldDecoratorTest.NamesToDescription[pair.Key];
                schema.SchemaDetails.Properties.Add(pair.Key, property);
                implDetails.Add(property, new SchemaImplementationDetails());
            }

            var decorator = new StandardPropertyDecorator();
            IList<CodeMemberProperty> generatedProperties = decorator.GenerateAllProperties(
                name, schema.SchemaDetails, implDetails, internalClassProvider);

            Assert.NotNull(generatedProperties);
            Assert.AreEqual(StandardPropertyFieldDecoratorTest.NamesToType.Count, generatedProperties.Count);
            foreach (var field in generatedProperties)
            {
                Assert.That(
                    StandardPropertyFieldDecoratorTest.NamesToType.ContainsKey(field.Name.ToLower()),
                    "field name was not present in namesToType " + field.Name);
            }

            int item = 0;
            foreach (var pair in StandardPropertyFieldDecoratorTest.NamesToType)
            {
                var field = generatedProperties[item++];
                Assert.AreEqual(
                    pair.Key, field.Name.ToLower(),
                    string.Format("Name different for expected at index {0}", item - 1));
                Assert.AreEqual(
                    SchemaDecoratorUtil.GetCodeType(new JsonSchema { Type = pair.Value }, null, internalClassProvider)
                        .BaseType, field.Type.BaseType);
            }
        }
        public void DecorateClassTest()
        {
            // Init required vars.
            var decorator = new ResponseInterfaceDecorator();
            var declaration = new CodeTypeDeclaration();
            var schema = new MockSchema { SchemaDetails = new JsonSchema() };
            var internalClassProvider = new ObjectInternalClassProvider();
            var implDetails = new Dictionary<JsonSchema, SchemaImplementationDetails>();
            implDetails.Add(schema.SchemaDetails, new SchemaImplementationDetails());

            // Test edge cases.
            Assert.Throws(
                typeof(ArgumentNullException),
                () => decorator.DecorateClass(null, schema, implDetails, internalClassProvider));
            Assert.Throws(
                typeof(ArgumentNullException),
                () => decorator.DecorateClass(declaration, null, implDetails, internalClassProvider));
            Assert.Throws(
                typeof(ArgumentNullException),
                () => decorator.DecorateClass(declaration, schema, null, internalClassProvider));

            decorator.DecorateClass(declaration, schema, implDetails, internalClassProvider);
            Assert.AreEqual(0, declaration.BaseTypes.Count);
            Assert.AreEqual(0, declaration.Members.Count);

            // Test simple functionality.
            var details = new SchemaImplementationDetails { IsMethodResult = true };
            implDetails = new Dictionary<JsonSchema, SchemaImplementationDetails>
                                  { { schema.SchemaDetails, details } };

            decorator.DecorateClass(declaration, schema, implDetails, internalClassProvider);

            Assert.AreEqual(1, declaration.BaseTypes.Count);
            Assert.AreEqual(2, declaration.Members.Count); // 1 property with a field.

            // Test with already existing e-tag field.
            declaration = new CodeTypeDeclaration();
            declaration.Members.Add(new CodeMemberProperty() { Name = "ETag" });
            decorator.DecorateClass(declaration, schema, implDetails, internalClassProvider);

            Assert.AreEqual(1, declaration.BaseTypes.Count);
            Assert.AreEqual(1, declaration.Members.Count);
        }
        public void DecorateClassTest()
        {
            var decorator = new StandardPropertyDecorator();
            var declaration = new CodeTypeDeclaration();
            var schema = new MockSchema() { Name = "TestSchema", SchemaDetails = new JsonSchema() };
            var internalClassProvider = new ObjectInternalClassProvider();
            var implDetails = new Dictionary<JsonSchema, SchemaImplementationDetails>();

            Assert.Throws(
                typeof(ArgumentNullException),
                () => decorator.DecorateClass(null, schema, implDetails, internalClassProvider));
            Assert.Throws(
                typeof(ArgumentNullException),
                () => decorator.DecorateClass(declaration, null, implDetails, internalClassProvider));
            Assert.Throws(
                typeof(ArgumentNullException),
                () => decorator.DecorateClass(declaration, schema, null, internalClassProvider));

            decorator.DecorateClass(declaration, schema, implDetails, internalClassProvider);
        }
Exemple #13
0
        public void DecorateClassTest()
        {
            var decorator   = new StandardPropertyDecorator();
            var declaration = new CodeTypeDeclaration();
            var schema      = new MockSchema()
            {
                Name = "TestSchema", SchemaDetails = new JsonSchema()
            };
            var internalClassProvider = new ObjectInternalClassProvider();
            var implDetails           = new Dictionary <JsonSchema, SchemaImplementationDetails>();

            Assert.Throws(
                typeof(ArgumentNullException),
                () => decorator.DecorateClass(null, schema, implDetails, internalClassProvider));
            Assert.Throws(
                typeof(ArgumentNullException),
                () => decorator.DecorateClass(declaration, null, implDetails, internalClassProvider));
            Assert.Throws(
                typeof(ArgumentNullException),
                () => decorator.DecorateClass(declaration, schema, null, internalClassProvider));

            decorator.DecorateClass(declaration, schema, implDetails, internalClassProvider);
        }
        public void GetCodeTypeTest()
        {
            var schema = new JsonSchema();
            var internalClassProvider = new ObjectInternalClassProvider();

            schema.Type = JsonSchemaType.String;
            CodeTypeReference result = SchemaDecoratorUtil.GetCodeType(schema, null, internalClassProvider);
            Assert.AreEqual(typeof(string).FullName, result.BaseType);

            schema.Type = JsonSchemaType.Integer;
            result = SchemaDecoratorUtil.GetCodeType(schema, null, internalClassProvider);
            Assert.AreEqual(typeof(Nullable<>).FullName, result.BaseType);
            Assert.AreEqual(typeof(long).FullName, result.TypeArguments[0].BaseType);

            schema.Type = JsonSchemaType.Float;
            result = SchemaDecoratorUtil.GetCodeType(schema, null, internalClassProvider);
            Assert.AreEqual(typeof(Nullable<>).FullName, result.BaseType);
            Assert.AreEqual(typeof(double).FullName, result.TypeArguments[0].BaseType);

            schema.Type = JsonSchemaType.Boolean;
            result = SchemaDecoratorUtil.GetCodeType(schema, null, internalClassProvider);
            Assert.AreEqual(typeof(Nullable<>).FullName, result.BaseType);
            Assert.AreEqual(typeof(bool).FullName, result.TypeArguments[0].BaseType);
        }
        public void DecorateClassTestEdgeCases()
        {
            var implDetails = new Dictionary<JsonSchema, SchemaImplementationDetails>();
            var decorator = new ArraySchemaDecorator();
            var internalClassProvider = new ObjectInternalClassProvider();
            CodeTypeDeclaration declaration = null;

            var schema = new MockSchema();
            schema.Name = "test";
            schema.SchemaDetails = null;
            Assert.Throws(
                typeof(ArgumentNullException),
                () => decorator.DecorateClass(new CodeTypeDeclaration(), schema, implDetails, internalClassProvider));

            schema.SchemaDetails = new JsonSchema();
            schema.SchemaDetails.Type = JsonSchemaType.Float;
            Assert.DoesNotThrow(
                () =>
                decorator.DecorateClass(
                    declaration = new CodeTypeDeclaration(), schema, implDetails, internalClassProvider));
            Assert.That(declaration.BaseTypes.Count, Is.EqualTo(0));

            schema.SchemaDetails.Type = JsonSchemaType.Array;
            schema.SchemaDetails.Items = new List<JsonSchema>();
            schema.SchemaDetails.Items.Add(new JsonSchema());
            schema.SchemaDetails.Items.Add(new JsonSchema());
            Assert.DoesNotThrow(
                () =>
                decorator.DecorateClass(
                    declaration = new CodeTypeDeclaration(), schema, implDetails, internalClassProvider));
            Assert.That(declaration.BaseTypes.Count, Is.EqualTo(0));
        }
        public void GenerateAllPropertiesTestEdgeCases()
        {
            var implDetails = new Dictionary<JsonSchema, SchemaImplementationDetails>();
            var decorator = new StandardPropertyDecorator();
            var internalClassProvider = new ObjectInternalClassProvider();
            string name = "test";
            Assert.Throws(
                typeof(ArgumentNullException),
                () => decorator.GenerateAllProperties(name, null, implDetails, internalClassProvider));

            var schema = new MockSchema();
            schema.Name = "test";
            schema.SchemaDetails = null;
            Assert.Throws(
                typeof(ArgumentNullException),
                () => decorator.GenerateAllProperties(name, schema.SchemaDetails, implDetails, internalClassProvider));

            schema.SchemaDetails = new JsonSchema();
            schema.SchemaDetails.Properties = null;
            Assert.Throws(
                typeof(ArgumentNullException),
                () => decorator.GenerateAllProperties(null, schema.SchemaDetails, implDetails, internalClassProvider));
            var expectedEmpty = decorator.GenerateAllProperties(
                name, schema.SchemaDetails, implDetails, internalClassProvider);
            Assert.IsNotNull(expectedEmpty);
            Assert.AreEqual(0, expectedEmpty.Count);
        }