public void TestReportTitleConflictWhenBothHaveTitle()
		{
			var schema1 = new JSchema
			{
				Title = "s1"
			};
			var schema2 = new JSchema
			{
				Title = "s2"
			};

			var underTest = new SchemaCombiner();
			var report = new SchemaComparisionReport();
			var result = underTest.Apply(schema1, schema2, report);

			var failures = report.GetFailures().ToList();

			Assert.AreEqual(1, failures.Count, "One failure expected");
			Assert.IsInstanceOfType(failures[0], typeof(ValueConflict));

			var valueConflict = (ValueConflict)failures[0];
			Assert.AreEqual("title", valueConflict.PropertyName);
			Assert.AreEqual(schema1, valueConflict.SchemaPart);
			Assert.AreEqual(schema2, valueConflict.SchemaBasePart);
			Assert.AreEqual("s1", valueConflict.Value1);
			Assert.AreEqual("s2", valueConflict.Value2);
		}
        public void TestReportTitleConflictWhenBothHaveTitle()
        {
            var schema1 = new JSchema
            {
                Title = "s1"
            };
            var schema2 = new JSchema
            {
                Title = "s2"
            };

            var underTest = new SchemaCombiner();
            var report    = new SchemaComparisionReport();
            var result    = underTest.Apply(schema1, schema2, report);

            var failures = report.GetFailures().ToList();

            Assert.AreEqual(1, failures.Count, "One failure expected");
            Assert.IsInstanceOfType(failures[0], typeof(ValueConflict));

            var valueConflict = (ValueConflict)failures[0];

            Assert.AreEqual("title", valueConflict.PropertyName);
            Assert.AreEqual(schema1, valueConflict.SchemaPart);
            Assert.AreEqual(schema2, valueConflict.SchemaBasePart);
            Assert.AreEqual("s1", valueConflict.Value1);
            Assert.AreEqual("s2", valueConflict.Value2);
        }
        public void TestAnyPropertyFromBaseSchemaShouldBeTaken()
        {
            var comparer = new SchemaComparer();
            var report = new SchemaComparisionReport();
            var resultSchema = comparer.Apply(GetSchema(Path.Combine(TestContext.DeploymentDirectory, "Comparisions/anyPropertyInMoreSpecific.json")),
                GetSchema(Path.Combine(TestContext.DeploymentDirectory, "Comparisions/anyPropertyInMoreSpecific_base.json")),
                report);

            Assert.IsNotNull(resultSchema);
            Assert.AreEqual("val1", resultSchema.Properties["name"].Format);
            //Assert.AreEqual("TestModel", resultSchema.Properties["prop2"], "val2");
        }
        public void TestAnyPropertyFromBaseSchemaShouldBeTaken()
        {
            var comparer     = new SchemaComparer();
            var report       = new SchemaComparisionReport();
            var resultSchema = comparer.Apply(GetSchema(Path.Combine(TestContext.DeploymentDirectory, "Comparisions/anyPropertyInMoreSpecific.json")),
                                              GetSchema(Path.Combine(TestContext.DeploymentDirectory, "Comparisions/anyPropertyInMoreSpecific_base.json")),
                                              report);

            Assert.IsNotNull(resultSchema);
            Assert.AreEqual("val1", resultSchema.Properties["name"].Format);
            //Assert.AreEqual("TestModel", resultSchema.Properties["prop2"], "val2");
        }
        public void TestInfoOnMissingPropertyInBaseSchema()
        {
            var comparer = new SchemaComparer();
            var report = new SchemaComparisionReport();
            var resultSchema = comparer.Apply(GetSchema(Path.Combine(TestContext.DeploymentDirectory, "Comparisions/infoOnMissingPropertyInBaseSchema.json")),
                GetSchema(Path.Combine(TestContext.DeploymentDirectory, "Comparisions/infoOnMissingPropertyInBaseSchema_base.json")),
                report);

            var infos = report.GetInfos().ToList();
            Assert.AreEqual(1, infos.Count, "one failure expected.");
            Assert.IsInstanceOfType(infos[0], typeof(MissingPropertyInfo), "Expected to be a MissingPropertyInfo");
            Assert.AreEqual("missingPropertyInBase", ((MissingPropertyInfo)infos[0]).PropertyName);
        }
        public void TestInvalidTypeChange()
        {
            var comparer = new SchemaComparer();
            var report = new SchemaComparisionReport();
            var resultSchema = comparer.Apply(GetSchema(Path.Combine(TestContext.DeploymentDirectory, "Comparisions/invalidTypeChangeInBase.json")),
                GetSchema(Path.Combine(TestContext.DeploymentDirectory, "Comparisions/invalidTypeChangeInBase_base.json")),
                report);

            var failures = report.GetFailures().ToList();
            Assert.AreEqual(1, failures.Count, "one failure expected.");
            Assert.IsInstanceOfType(failures[0], typeof(TypeChangeFailure), "Expected to be a TypeChangeFailure");
            Assert.AreEqual("name", ((TypeChangeFailure)failures[0]).PropertyName);
        }
        public void TestInfoOnMissingPropertyInBaseSchema()
        {
            var comparer = new SchemaComparer();
            var report = new SchemaComparisionReport();
            var resultSchema = comparer.Apply(GetSchema(Path.Combine(PathUtility.GetDirectory(), "Mocks/Comparisions/infoOnMissingPropertyInBaseSchema.json")),
                GetSchema(Path.Combine(PathUtility.GetDirectory(), "Mocks/Comparisions/infoOnMissingPropertyInBaseSchema_base.json")),
                report);

            var infos = report.GetInfos().ToList();
            Assert.Equal(1, infos.Count);
            Assert.IsType(typeof(MissingPropertyInfo), infos[0]);
            Assert.Equal("missingPropertyInBase", ((MissingPropertyInfo)infos[0]).PropertyName);
        }
        public void TestInvalidTypeChange()
        {
            var comparer = new SchemaComparer();
            var report = new SchemaComparisionReport();
            var resultSchema = comparer.Apply(GetSchema(Path.Combine(PathUtility.GetDirectory(), "Mocks/Comparisions/invalidTypeChangeInBase.json")),
                GetSchema(Path.Combine(PathUtility.GetDirectory(), "Mocks/Comparisions/invalidTypeChangeInBase_base.json")),
                report);

            var failures = report.GetFailures().ToList();
            Assert.Equal(1, failures.Count);
            Assert.IsType(typeof(TypeChangeFailure), failures[0]);
            Assert.Equal("name", ((TypeChangeFailure)failures[0]).PropertyName);
        }
        public void TestInfoOnMissingPropertyInBaseSchema()
        {
            var comparer     = new SchemaComparer();
            var report       = new SchemaComparisionReport();
            var resultSchema = comparer.Apply(GetSchema(Path.Combine(TestContext.DeploymentDirectory, "Comparisions/infoOnMissingPropertyInBaseSchema.json")),
                                              GetSchema(Path.Combine(TestContext.DeploymentDirectory, "Comparisions/infoOnMissingPropertyInBaseSchema_base.json")),
                                              report);

            var infos = report.GetInfos().ToList();

            Assert.AreEqual(1, infos.Count, "one failure expected.");
            Assert.IsInstanceOfType(infos[0], typeof(MissingPropertyInfo), "Expected to be a MissingPropertyInfo");
            Assert.AreEqual("missingPropertyInBase", ((MissingPropertyInfo)infos[0]).PropertyName);
        }
        public void TestInvalidTypeChange()
        {
            var comparer     = new SchemaComparer();
            var report       = new SchemaComparisionReport();
            var resultSchema = comparer.Apply(GetSchema(Path.Combine(TestContext.DeploymentDirectory, "Comparisions/invalidTypeChangeInBase.json")),
                                              GetSchema(Path.Combine(TestContext.DeploymentDirectory, "Comparisions/invalidTypeChangeInBase_base.json")),
                                              report);

            var failures = report.GetFailures().ToList();

            Assert.AreEqual(1, failures.Count, "one failure expected.");
            Assert.IsInstanceOfType(failures[0], typeof(TypeChangeFailure), "Expected to be a TypeChangeFailure");
            Assert.AreEqual("name", ((TypeChangeFailure)failures[0]).PropertyName);
        }
        public async Task <JSchema> GetSchemaFromModuleAsync(ModuleDefinition module)
        {
            IEnumerable <TemplateInfo> templates;

            if (module.Skins != null)
            {
                templates = module.Skins.Values;
            }
            else
            {
                templates = Enumerable.Empty <TemplateInfo>();
            }

            if (module.DefaultTemplate != null)
            {
                templates = templates.Union(new[] { module.DefaultTemplate });
            }

            var enumerator = templates.GetEnumerator();

            if (!enumerator.MoveNext())
            {
                return(null);
            }

            var result = await _schemaProvider.GetSchemaFromTemplateAsync(enumerator.Current).ConfigureAwait(false);

            var report = new SchemaComparisionReport();

            while (enumerator.MoveNext())
            {
                var schema = await _schemaProvider.GetSchemaFromTemplateAsync(enumerator.Current).ConfigureAwait(false);

                result = _schemaCombiner.Apply(result, schema, report);
            }

            return(result);
        }