public void HM_WithRefPropsAndAssert_ShouldBe_Satisfiable()
        {
            // Arrange
            var objectTheorem = new ObjectTheoremContext();

            objectTheorem.RegisterSuperType <Vehicle>();
            var bicycleInstance1 = objectTheorem.CreateInstance <Bicycle>("BicycleInstance1");
            var bicycleInstance2 = objectTheorem.CreateInstance <Bicycle>("BicycleInstance2");
            var carInstance1     = objectTheorem.CreateInstance <Car>("CarInstance1");

            // Act
            objectTheorem.ConstraintBuilder
            .AssertAll <Vehicle>(v => v.Speed > 0)
            .AssertAll <Bicycle, Car>((b, c) => b.Speed < c.Speed)
            .Assert(() => bicycleInstance1.Speed == 10);

            // Assert
            var solved = objectTheorem.Solve();

            Assert.IsNotNull(solved);

            int bicycle1Speed = solved.GetValue(bicycleInstance1, i => i.Speed);
            int bicycle2Speed = solved.GetValue(bicycleInstance2, i => i.Speed);
            int carSpeed      = solved.GetValue(carInstance1, i => i.Speed);

            Assert.AreEqual(10, bicycle1Speed);
            Assert.IsTrue(bicycle2Speed > 0);

            Assert.IsTrue(carSpeed > 0);
            Assert.IsTrue(bicycle1Speed < carSpeed);
            Assert.IsTrue(bicycle2Speed < carSpeed);
        }
        public void ForeignKeyDiscoveryConvention_Successful_Satisfiable()
        {
            // Arrange
            var objectTheorem = new ObjectTheoremContext();

            objectTheorem.RegisterSuperType<Type>();
            objectTheorem.RegisterSuperType<Field>();
            objectTheorem.RegisterSuperType<ReferenceField>();

            var nullType = objectTheorem.CreateInstance<ReferenceType>("NullType");

            var categoryType = objectTheorem.CreateInstance<ReferenceType>("CategoryType");
            var categoryIdField = objectTheorem.CreateInstance<ValueField>("CategoryIdField");

            var productType = objectTheorem.CreateInstance<ReferenceType>("ProductType");
            var productIdField = objectTheorem.CreateInstance<ValueField>("ProductIdField");

            var productCategoryIdField = objectTheorem.CreateInstance<ValueField>("productCategoryIdField");
            var productCategoryField = objectTheorem.CreateInstance<SingleField>("productCategoryField");

            var stringType = objectTheorem.CreateInstance<ValueType>("StringType");
            var numberType = objectTheorem.CreateInstance<ValueType>("NumberType");
            var guidType = objectTheorem.CreateInstance<ValueType>("GuidType");

            objectTheorem.SetPossibleStringValues("CatId", "ProdId", "CategoryId", "Category", "-");

            // Act
            objectTheorem.ConstraintBuilder
                .AssertAll<SingleField>(sf => sf.Owner.ValueFields.Any(vf => vf.Name == sf.ForeignKeyAttribute && vf.ForeignType == sf.Type))
                .AssertAll<ValueField>(vf => vf.ForeignType == nullType ^ vf.ForeignType.ValueFields.Any(vf2 => vf2.IsPrimaryKey && vf2.Type == vf.Type))

                .Assert(() => categoryIdField.Owner == categoryType)
                .Assert(() => categoryIdField.Name == "CatId")
                .Assert(() => categoryIdField.Type == stringType)
                .Assert(() => categoryIdField.IsPrimaryKey == true)
                .Assert(() => categoryType.ValueFields == new[] { categoryIdField })

                .Assert(() => productIdField.Owner == productType)
                .Assert(() => productIdField.Name == "ProdId")
                .Assert(() => productIdField.Type == guidType)
                .Assert(() => productIdField.IsPrimaryKey == true)
                .Assert(() => productCategoryIdField.Owner == productType)
                .Assert(() => productCategoryIdField.Name == "CategoryId")
                .Assert(() => productCategoryIdField.Type == stringType)
                .Assert(() => productCategoryField.Owner == productType)
                .Assert(() => productCategoryField.Name == "Category")
                .Assert(() => productCategoryField.Type == categoryType)
                .Assert(() => productType.ValueFields == new[] { productIdField, productCategoryIdField })
                .Assert(() => productType.SingleFields == new[] { productCategoryField });

            var assume1 = objectTheorem.ConstraintBuilder.Assume(() => productCategoryField.ForeignKeyAttribute == "CategoryId");

            // Assert
            var solved = objectTheorem.Solve();
            Assert.IsNotNull(solved);
            Assert.AreEqual(Status.Satisfiable, solved.Status);

            var test = solved.GetValue(productCategoryIdField, p => p.Type);
            Assert.AreEqual(stringType, test);
        }
        public void IndexRule_Successful_Satisfiable()
        {
            // Arrange
            var objectTheorem = new ObjectTheoremContext();

            objectTheorem.RegisterSuperType<Type>();
            objectTheorem.RegisterSuperType<Field>();

            var valueField1 = objectTheorem.CreateInstance<ValueField>("ValueField1");

            var stringType = objectTheorem.CreateInstance<ValueType>("StringType");

            // Act
            EFConstraints.AddIndexRuleConstraints(objectTheorem.ConstraintBuilder, stringType);

            objectTheorem.ConstraintBuilder
                .Assert(() => valueField1.Type == stringType);

            var assume1 = objectTheorem.ConstraintBuilder.Assume(() => valueField1.HasIndexAttribute == true);
            var assume2 = objectTheorem.ConstraintBuilder.Assume(() => valueField1.HasMaxLengthAttribute == true);

            // Assert
            var solved = objectTheorem.Solve();
            Assert.IsNotNull(solved);
            Assert.AreEqual(Status.Satisfiable, solved.Status);
        }
        public void EFMetaModel_ShouldBe_Satisfiable()
        {
            // Arrange
            var objectTheorem = new ObjectTheoremContext();

            var typeInstance1 = objectTheorem.CreateInstance <Category>("TypeInstance1");
            var typeInstance2 = objectTheorem.CreateInstance <Category>("TypeInstance2");

            var fieldInstance1 = objectTheorem.CreateInstance <Product>("FieldInstance1");
            var fieldInstance2 = objectTheorem.CreateInstance <Product>("FieldInstance2");

            // Act
            objectTheorem.ConstraintBuilder
            .AssertAll <Product>((f) => !f.Category.IsHighlighted || f.IsPremiumOnly == true)
            .Assert(() => typeInstance1.IsHighlighted == true)
            .Assert(() => fieldInstance1.Category == typeInstance1)
            .Assert(() => fieldInstance2.Category == typeInstance2)
            .Assert(() => !fieldInstance2.IsPremiumOnly);


            // Assert
            var solved = objectTheorem.Solve();

            Assert.IsNotNull(solved);

            bool oneHasKeyAttribute = solved.GetValue(fieldInstance1, i => i.IsPremiumOnly);
            bool twoHasKeyAttribute = solved.GetValue(fieldInstance2, i => i.IsPremiumOnly);

            Assert.IsTrue(oneHasKeyAttribute);
            Assert.IsFalse(twoHasKeyAttribute);
        }
Example #5
0
        public void IndexRule_Successful_Satisfiable()
        {
            // Arrange
            var objectTheorem = new ObjectTheoremContext();

            objectTheorem.RegisterSuperType <Type>();
            objectTheorem.RegisterSuperType <Field>();

            var valueField1 = objectTheorem.CreateInstance <ValueField>("ValueField1");

            var stringType = objectTheorem.CreateInstance <ValueType>("StringType");

            // Act
            EFConstraints.AddIndexRuleConstraints(objectTheorem.ConstraintBuilder, stringType);

            objectTheorem.ConstraintBuilder
            .Assert(() => valueField1.Type == stringType);

            var assume1 = objectTheorem.ConstraintBuilder.Assume(() => valueField1.HasIndexAttribute == true);
            var assume2 = objectTheorem.ConstraintBuilder.Assume(() => valueField1.HasMaxLengthAttribute == true);

            // Assert
            var solved = objectTheorem.Solve();

            Assert.IsNotNull(solved);
            Assert.AreEqual(Status.Satisfiable, solved.Status);
        }
        public void ComplexTypeConvention_Successful_Satisfiable()
        {
            // Arrange
            var objectTheorem = new ObjectTheoremContext();

            objectTheorem.RegisterSuperType <Z3.ObjectTheorem.EF.Metamodel.Field>();
            objectTheorem.RegisterSuperType <Z3.ObjectTheorem.EF.Metamodel.Type>();

            var addressType = objectTheorem.CreateInstance <ReferenceType>("AddressType");
            var nameField   = objectTheorem.CreateInstance <ValueField>("NameField");

            // Act
            EFConstraints.AddComplexTypeRuleConstraints(objectTheorem.ConstraintBuilder);

            objectTheorem.ConstraintBuilder
            .Assert(() => !addressType.HasCollectionFields && !addressType.HasSingleFields)
            .Assert(() => addressType.ValueFields == new[] { nameField });

            var assume1 = objectTheorem.ConstraintBuilder.Assume(() => addressType.HasComplexTypeAttribute == true);

            // Assert
            var solved = objectTheorem.Solve();

            Assert.IsNotNull(solved);
            Assert.AreEqual(Status.Satisfiable, solved.Status);

            bool HasComplexTypeAttribute = solved.GetValue(addressType, i => i.HasComplexTypeAttribute);

            Assert.IsTrue(HasComplexTypeAttribute);
        }
        public void SimpleModel_OutsideConstant_ShouldBe_Satisfiable()
        {
            // Arrange
            var objectTheorem = new ObjectTheoremContext();

            var outsideBoolConstant = true;

            var classAInstance = objectTheorem.CreateInstance <ClassA>("ClassAInstance");
            var classBInstance = objectTheorem.CreateInstance <ClassB>("ClassBInstance");

            // Act
            objectTheorem.ConstraintBuilder
            .AssertAll <ClassA, ClassB>((a, b) => a.IsValidA == b.IsValidB)
            .Assert(() => classAInstance.IsValidA == outsideBoolConstant);

            // Assert
            var solved = objectTheorem.Solve();

            Assert.IsNotNull(solved);

            bool isValidA = solved.GetValue(classAInstance, i => i.IsValidA);
            bool isValidB = solved.GetValue(classBInstance, i => i.IsValidB);

            Assert.IsTrue(isValidA);
            Assert.IsTrue(isValidB);
        }
        public void WithAnyAndAll_TwoItemArray_ShouldBe_Unsatisfiable2()
        {
            // Arrange
            var objectTheorem = new ObjectTheoremContext();

            var typeInstance1 = objectTheorem.CreateInstance <Category>("TypeInstance1");

            var fieldInstance1 = objectTheorem.CreateInstance <Product>("FieldInstance1");
            var fieldInstance2 = objectTheorem.CreateInstance <Product>("FieldInstance2");

            // Act
            objectTheorem.ConstraintBuilder
            .AssertAll <Category>(t => t.Products.Any(f1 => f1.IsPremiumOnly == true &&
                                                      t.Products.All(f2 => f2 == f1 || f2.IsPremiumOnly == false)))
            .Assert(() => typeInstance1.Products == new[] { fieldInstance1, fieldInstance2 })
            .Assert(() => fieldInstance1.Category == typeInstance1)
            .Assert(() => fieldInstance2.Category == typeInstance1)
            .Assert(() => fieldInstance1.IsPremiumOnly == false)
            .Assert(() => fieldInstance2.IsPremiumOnly == false);

            // Assert
            var solved = objectTheorem.Solve();

            Assert.IsNull(solved);
        }
        public void DatabaseGeneratedRule_Successful_Satisfiable()
        {
            // Arrange
            var objectTheorem = new ObjectTheoremContext();

            objectTheorem.RegisterSuperType<Type>();
            var employeeType = objectTheorem.CreateInstance<ReferenceType>("EmployeeType");

            objectTheorem.RegisterSuperType<Field>();
            objectTheorem.SetPossibleStringValues("Id", "ID", "EmployeeTypeId", "EmployeeTypeID");
            var idField = objectTheorem.CreateInstance<ValueField>("IdField");

            var stringType = objectTheorem.CreateInstance<ValueType>("StringType");
            var numberType = objectTheorem.CreateInstance<ValueType>("NumberType");
            var guidType = objectTheorem.CreateInstance<ValueType>("GuidType");

            // Act
            EFConstraints.AddPrimayKeyRuleConstraints(objectTheorem.ConstraintBuilder);
            EFConstraints.AddDatabaseGeneratedRuleConstraints(objectTheorem.ConstraintBuilder, stringType, numberType, guidType);

            objectTheorem.ConstraintBuilder
                .Assert(() => employeeType.IsEntity == true)
                .Assert(() => employeeType.ValueFields == new[] { idField })
                .Assert(() => idField.Name == "Id")
                .Assert(() => idField.Owner == employeeType)
                .Assert(() => idField.Type == numberType)
                .Assert(() => idField.DatabaseGeneratedAttribute == DatabaseGeneratedAttribute.None);

            var assume1 = objectTheorem.ConstraintBuilder.Assume(() => idField.DatabaseGeneratedAttribute == DatabaseGeneratedAttribute.None);

            // Assert
            var solved = objectTheorem.Solve();
            Assert.IsNotNull(solved);
            Assert.AreEqual(Status.Satisfiable, solved.Status);
        }
        public void SM_WithStringPropsAndSamePossibleStrings_ShouldBe_Satisfiable()
        {
            // Arrange
            var objectTheorem = new ObjectTheoremContext();

            var stringNames = new[] { "Hans", "Fred", "Max" };

            objectTheorem.SetPossibleStringValues(stringNames);

            var classWithStringA = objectTheorem.CreateInstance<ClassWithStringA>("ClassWithStringA");
            var classWithStringB = objectTheorem.CreateInstance<ClassWithStringB>("ClassWithStringB");

            // Act
            objectTheorem.ConstraintBuilder
                .AssertAll<ClassWithStringA, ClassWithStringB>((a, b) => a.FirstName == b.LastName)
                .Assert(() => "Hans" == classWithStringA.FirstName);

            // Assert
            var solved = objectTheorem.Solve();
            Assert.IsNotNull(solved);

            string firstName = solved.GetValue(classWithStringA, i => i.FirstName);
            string lastName = solved.GetValue(classWithStringB, i => i.LastName);
            Assert.AreEqual("Hans", firstName);
            Assert.AreEqual("Hans", lastName);
        }
        public void ComplexTypeConvention_Successful_Satisfiable()
        {
            // Arrange
            var objectTheorem = new ObjectTheoremContext();

            objectTheorem.RegisterSuperType<Z3.ObjectTheorem.EF.Metamodel.Field>();
            objectTheorem.RegisterSuperType<Z3.ObjectTheorem.EF.Metamodel.Type>();

            var addressType = objectTheorem.CreateInstance<ReferenceType>("AddressType");
            var nameField = objectTheorem.CreateInstance<ValueField>("NameField");

            // Act
            EFConstraints.AddComplexTypeRuleConstraints(objectTheorem.ConstraintBuilder);

            objectTheorem.ConstraintBuilder
                .Assert(() => !addressType.HasCollectionFields && !addressType.HasSingleFields)
                .Assert(() => addressType.ValueFields == new[] { nameField });

            var assume1 = objectTheorem.ConstraintBuilder.Assume(() => addressType.HasComplexTypeAttribute == true);

            // Assert
            var solved = objectTheorem.Solve();
            Assert.IsNotNull(solved);
            Assert.AreEqual(Status.Satisfiable, solved.Status);

            bool HasComplexTypeAttribute = solved.GetValue(addressType, i => i.HasComplexTypeAttribute);
            Assert.IsTrue(HasComplexTypeAttribute);
        }
        public void EFMetaModel_WithAny_TwoItemArray_ShouldBe_Satisfiable()
        {
            // Arrange
            var objectTheorem = new ObjectTheoremContext();

            var typeInstance1 = objectTheorem.CreateInstance<Category>("TypeInstance1");

            var fieldInstance1 = objectTheorem.CreateInstance<Product>("FieldInstance1");
            var fieldInstance2 = objectTheorem.CreateInstance<Product>("FieldInstance2");

            // Act
            objectTheorem.ConstraintBuilder
                    .AssertAll<Category>(t => t.Products.Any(f1 => f1.IsPremiumOnly == true))
                    .Assert(() => typeInstance1.Products == new[] { fieldInstance1, fieldInstance2 })
                    .Assert(() => fieldInstance1.Category == typeInstance1)
                    .Assert(() => fieldInstance2.Category == typeInstance1)
                    .Assert(() => fieldInstance1.IsPremiumOnly == true)
                    .Assert(() => fieldInstance2.IsPremiumOnly == true);

            // Assert
            var solved = objectTheorem.Solve();
            Assert.IsNotNull(solved);

            bool oneHasKeyAttribute = solved.GetValue(fieldInstance1, i => i.IsPremiumOnly);
            bool twoHasKeyAttribute = solved.GetValue(fieldInstance2, i => i.IsPremiumOnly);
            Assert.IsTrue(oneHasKeyAttribute);
            Assert.IsTrue(twoHasKeyAttribute);
        }
        public void EnumValuesFromOutside_ShouldBe_Satisfiable2()
        {
            // Arrange
            var objectTheorem = new ObjectTheoremContext();

            var classAInstance1 = objectTheorem.CreateInstance <ClassA>("ClassAInstance");
            var classAInstance2 = objectTheorem.CreateInstance <ClassA>("ClassBInstance");

            // Act
            var color = Colors.Black;

            objectTheorem.ConstraintBuilder
            .Assert(() => classAInstance1.Color != classAInstance2.Color)
            .Assert(() => classAInstance1.Color == color);

            // Assert
            var solved = objectTheorem.Solve();

            Assert.IsNotNull(solved);

            Colors color1 = solved.GetValue(classAInstance1, i => i.Color);
            Colors color2 = solved.GetValue(classAInstance2, i => i.Color);

            Assert.IsTrue(color1 != color2);
            Assert.AreEqual(color, color1);
        }
        public void EFMetaModel_ShouldBe_Satisfiable()
        {
            // Arrange
            var objectTheorem = new ObjectTheoremContext();

            var typeInstance1 = objectTheorem.CreateInstance<Category>("TypeInstance1");
            var typeInstance2 = objectTheorem.CreateInstance<Category>("TypeInstance2");

            var fieldInstance1 = objectTheorem.CreateInstance<Product>("FieldInstance1");
            var fieldInstance2 = objectTheorem.CreateInstance<Product>("FieldInstance2");

            // Act
            objectTheorem.ConstraintBuilder
                    .AssertAll<Product>((f) => !f.Category.IsHighlighted || f.IsPremiumOnly == true)
                    .Assert(() => typeInstance1.IsHighlighted == true)
                    .Assert(() => fieldInstance1.Category == typeInstance1)
                    .Assert(() => fieldInstance2.Category == typeInstance2)
                    .Assert(() => !fieldInstance2.IsPremiumOnly);


            // Assert
            var solved = objectTheorem.Solve();
            Assert.IsNotNull(solved);

            bool oneHasKeyAttribute = solved.GetValue(fieldInstance1, i => i.IsPremiumOnly);
            bool twoHasKeyAttribute = solved.GetValue(fieldInstance2, i => i.IsPremiumOnly);
            Assert.IsTrue(oneHasKeyAttribute);
            Assert.IsFalse(twoHasKeyAttribute);
        }
Example #15
0
        public void EFMetaModel_WithAll_TwoItemArray_ShouldBe_Satisfiable()
        {
            // Arrange
            var objectTheorem = new ObjectTheoremContext();

            var typeInstance1 = objectTheorem.CreateInstance <Category>("TypeInstance1");

            var fieldInstance1 = objectTheorem.CreateInstance <Product>("FieldInstance1");
            var fieldInstance2 = objectTheorem.CreateInstance <Product>("FieldInstance2");

            // Act
            objectTheorem.ConstraintBuilder
            .AssertAll <Category>(t => t.Products.All(f => f.IsPremiumOnly == true))
            .Assert(() => typeInstance1.Products == new[] { fieldInstance1, fieldInstance2 })
            .Assert(() => fieldInstance1.Category == typeInstance1)
            .Assert(() => fieldInstance2.Category == typeInstance1)
            .Assert(() => fieldInstance1.IsPremiumOnly == true)
            .Assert(() => fieldInstance2.IsPremiumOnly == true);

            // Assert
            var solved = objectTheorem.Solve();

            Assert.IsNotNull(solved);

            bool oneHasKeyAttribute = solved.GetValue(fieldInstance1, i => i.IsPremiumOnly);
            bool twoHasKeyAttribute = solved.GetValue(fieldInstance2, i => i.IsPremiumOnly);

            Assert.IsTrue(oneHasKeyAttribute);
            Assert.IsTrue(twoHasKeyAttribute);
        }
        public void HM_WithRefPropsAndAssert_ShouldBe_Satisfiable()
        {
            // Arrange
            var objectTheorem = new ObjectTheoremContext();

            objectTheorem.RegisterSuperType<Vehicle>();
            var bicycleInstance1 = objectTheorem.CreateInstance<Bicycle>("BicycleInstance1");
            var bicycleInstance2 = objectTheorem.CreateInstance<Bicycle>("BicycleInstance2");
            var carInstance1 = objectTheorem.CreateInstance<Car>("CarInstance1");

            // Act
            objectTheorem.ConstraintBuilder
                .AssertAll<Vehicle>(v => v.Speed > 0)
                .AssertAll<Bicycle, Car>((b, c) => b.Speed < c.Speed)
                .Assert(() => bicycleInstance1.Speed == 10);

            // Assert
            var solved = objectTheorem.Solve();
            Assert.IsNotNull(solved);

            int bicycle1Speed = solved.GetValue(bicycleInstance1, i => i.Speed);
            int bicycle2Speed = solved.GetValue(bicycleInstance2, i => i.Speed);
            int carSpeed = solved.GetValue(carInstance1, i => i.Speed);

            Assert.AreEqual(10, bicycle1Speed);
            Assert.IsTrue(bicycle2Speed > 0);
            
            Assert.IsTrue(carSpeed > 0);
            Assert.IsTrue(bicycle1Speed < carSpeed);
            Assert.IsTrue(bicycle2Speed < carSpeed);
        }
Example #17
0
        public void SM_WithStringPropsAndSamePossibleStrings_ShouldBe_Satisfiable()
        {
            // Arrange
            var objectTheorem = new ObjectTheoremContext();

            var stringNames = new[] { "Hans", "Fred", "Max" };

            objectTheorem.SetPossibleStringValues(stringNames);

            var classWithStringA = objectTheorem.CreateInstance <ClassWithStringA>("ClassWithStringA");
            var classWithStringB = objectTheorem.CreateInstance <ClassWithStringB>("ClassWithStringB");

            // Act
            objectTheorem.ConstraintBuilder
            .AssertAll <ClassWithStringA, ClassWithStringB>((a, b) => a.FirstName == b.LastName)
            .Assert(() => "Hans" == classWithStringA.FirstName);

            // Assert
            var solved = objectTheorem.Solve();

            Assert.IsNotNull(solved);

            string firstName = solved.GetValue(classWithStringA, i => i.FirstName);
            string lastName  = solved.GetValue(classWithStringB, i => i.LastName);

            Assert.AreEqual("Hans", firstName);
            Assert.AreEqual("Hans", lastName);
        }
        public void EFMetaModel_WithRefPropsAndAssert_ShouldBe_Satisfiable()
        {
            // Arrange
            var objectTheorem = new ObjectTheoremContext();

            var typeInstance1  = objectTheorem.CreateInstance <Category>("TypeInstance1");
            var typeInstance2  = objectTheorem.CreateInstance <Category>("TypeInstance2");
            var fieldInstance1 = objectTheorem.CreateInstance <Product>("FieldInstance1");

            // Act
            objectTheorem.ConstraintBuilder
            .Assert(() => typeInstance1.IsHighlighted == false)
            .Assert(() => fieldInstance1.Category == typeInstance2)
            .Assert(() => fieldInstance1.Category.IsHighlighted == true);

            // Assert
            var solved = objectTheorem.Solve();

            Assert.IsNotNull(solved);

            bool IsEntity1 = solved.GetValue(typeInstance1, i => i.IsHighlighted);
            bool IsEntity2 = solved.GetValue(typeInstance2, i => i.IsHighlighted);

            Assert.IsFalse(IsEntity1);
            Assert.IsTrue(IsEntity2);
        }
        public void IdKeyDiscoveryConvention_And_KeyAttributeConvention_Unsuccessful_Unsatisfiable_()
        {
            // Arrange
            var objectTheorem = new ObjectTheoremContext();

            objectTheorem.RegisterSuperType<Z3.ObjectTheorem.EF.Metamodel.Type>();
            var employeeType = objectTheorem.CreateInstance<ReferenceType>("EmployeeType");

            objectTheorem.RegisterSuperType<Field>();
            objectTheorem.SetPossibleStringValues("Id", "Title", "Name", "Income", "ID", "EmployeeTypeId", "EmployeeTypeID");
            var titleField = objectTheorem.CreateInstance<ValueField>("TitleField");
            var nameField = objectTheorem.CreateInstance<ValueField>("NameField");
            var incomeField = objectTheorem.CreateInstance<ValueField>("IncomeField");

            // Act
            EFConstraints.AddPrimayKeyRuleConstraints(objectTheorem.ConstraintBuilder);

            objectTheorem.ConstraintBuilder
                .Assert(() => employeeType.IsEntity == true)
                .Assert(() => employeeType.ValueFields == new[] { titleField, nameField, incomeField })
                .Assert(() => titleField.Name == "Title")
                .Assert(() => titleField.Owner == employeeType)
                .Assert(() => nameField.Name == "Name")
                .Assert(() => nameField.Owner == employeeType)
                .Assert(() => incomeField.Name == "Income")
                .Assert(() => incomeField.Owner == employeeType);

            var assume1 = objectTheorem.ConstraintBuilder.Assume(() => titleField.HasKeyAttribute == false);
            var assume2 = objectTheorem.ConstraintBuilder.Assume(() => nameField.HasKeyAttribute == false);
            var assume3 = objectTheorem.ConstraintBuilder.Assume(() => incomeField.HasKeyAttribute == false);

            // Assert
            var solved = objectTheorem.Solve();
            Assert.IsNotNull(solved);
            Assert.AreEqual(Status.Unsatisfiable, solved.Status);

            var assume1Result = solved.IsAssumptionWrong(assume1);
            Assert.IsTrue(assume1Result);
            objectTheorem.ConstraintBuilder.RemoveAssumption(assume1);

            solved = objectTheorem.Solve();
            Assert.IsNotNull(solved);
            Assert.AreEqual(Status.Satisfiable, solved.Status);

            bool HasKeyAttribute1 = solved.GetValue(titleField, i => i.HasKeyAttribute);
            bool HasKeyAttribute2 = solved.GetValue(nameField, i => i.HasKeyAttribute);
            bool HasKeyAttribute3 = solved.GetValue(incomeField, i => i.HasKeyAttribute);
            Assert.IsTrue(HasKeyAttribute1);
            Assert.IsFalse(HasKeyAttribute2);
            Assert.IsFalse(HasKeyAttribute3);

            bool IsPrimaryKey1 = solved.GetValue(titleField, i => i.IsPrimaryKey);
            bool IsPrimaryKey2 = solved.GetValue(nameField, i => i.IsPrimaryKey);
            bool IsPrimaryKey3 = solved.GetValue(incomeField, i => i.IsPrimaryKey);
            Assert.IsTrue(IsPrimaryKey1);
            Assert.IsFalse(IsPrimaryKey2);
            Assert.IsFalse(IsPrimaryKey3);
        }
        public void NotMappedRule_Unsuccessful_Satisfiable()
        {
            // Arrange
            var objectTheorem = new ObjectTheoremContext();

            objectTheorem.RegisterSuperType<Type>();
            objectTheorem.RegisterSuperType<Field>();
            objectTheorem.RegisterSuperType<ReferenceField>();

            var customerType = objectTheorem.CreateInstance<ReferenceType>("Customer1");
            var addressType = objectTheorem.CreateInstance<ReferenceType>("Address1");

            var arrayOfAddressField = objectTheorem.CreateInstance<CollectionField>("AddressField");
            var namesField = objectTheorem.CreateInstance<ValueField>("NamesField");

            var arrayOfStringType = objectTheorem.CreateInstance<ValueType>("CollectionOfStringType");

            // Act
            EFConstraints.AddNotMappedRuleConstraints(objectTheorem.ConstraintBuilder, new[] { arrayOfStringType });

            objectTheorem.ConstraintBuilder
                .Assert(() => customerType.ValueFields == new[] { namesField })
                .Assert(() => namesField.Owner == customerType)
                .Assert(() => namesField.Type == arrayOfStringType)
                .Assert(() => customerType.CollectionFields == new[] { arrayOfAddressField })
                .Assert(() => arrayOfAddressField.Owner == customerType)
                .Assert(() => arrayOfAddressField.Type == addressType)
                .Assert(() => addressType.HasComplexTypeAttribute == true);

            var assume1 = objectTheorem.ConstraintBuilder.Assume(() => arrayOfAddressField.HasNotMappedAttribute == false);
            var assume2 = objectTheorem.ConstraintBuilder.Assume(() => namesField.HasNotMappedAttribute == false);

            // Assert
            var solved = objectTheorem.Solve();
            Assert.IsNotNull(solved);
            Assert.AreEqual(Status.Unsatisfiable, solved.Status);

            var assume1Result = solved.IsAssumptionWrong(assume1);
            Assert.IsTrue(assume1Result);
            objectTheorem.ConstraintBuilder.RemoveAssumption(assume1);

            solved = objectTheorem.Solve();
            Assert.IsNotNull(solved);
            Assert.AreEqual(Status.Unsatisfiable, solved.Status);

            var assume2Result = solved.IsAssumptionWrong(assume2);
            Assert.IsTrue(assume2Result);
            objectTheorem.ConstraintBuilder.RemoveAssumption(assume2);

            solved = objectTheorem.Solve();
            Assert.IsNotNull(solved);
            Assert.AreEqual(Status.Satisfiable, solved.Status);

            bool HasNotMappedAttribute1 = solved.GetValue(arrayOfAddressField, f => f.HasNotMappedAttribute);
            bool HasNotMappedAttribute2 = solved.GetValue(namesField, f => f.HasNotMappedAttribute);
            Assert.IsTrue(HasNotMappedAttribute1);
            Assert.IsTrue(HasNotMappedAttribute2);
        }
Example #21
0
        public void ForeignKeyTypeMatchRule_Unsuccessful_Satisfiable()
        {
            // Arrange
            var objectTheorem = new ObjectTheoremContext();

            objectTheorem.RegisterSuperType <Type>();
            objectTheorem.RegisterSuperType <Field>();
            objectTheorem.RegisterSuperType <ReferenceField>();

            var productType  = objectTheorem.CreateInstance <ReferenceType>("ProductType");
            var categoryType = objectTheorem.CreateInstance <ReferenceType>("CategoryType");

            var stringType = objectTheorem.CreateInstance <ValueType>("StringType");
            var guidType   = objectTheorem.CreateInstance <ValueType>("GuidType");

            var categoryField   = objectTheorem.CreateInstance <SingleField>("CategoryField");
            var categoryIdField = objectTheorem.CreateInstance <ValueField>("CategoryIdField");
            var idField         = objectTheorem.CreateInstance <ValueField>("IdField");

            objectTheorem.SetPossibleStringValues("ID", "Id", "CategoryId");

            // Act
            objectTheorem.ConstraintBuilder
            .Assert(() => categoryIdField.Type == idField.Type)

            .Assert(() => productType.SingleFields == new[] { categoryField })
            .Assert(() => categoryField.Owner == productType)
            .Assert(() => categoryField.Type == categoryType)
            .Assert(() => productType.ValueFields == new[] { categoryIdField })
            .Assert(() => categoryIdField.Owner == productType)
            .Assert(() => categoryIdField.Name == "CategoryId")
            .Assert(() => categoryType.ValueFields == new[] { idField })
            .Assert(() => idField.Owner == categoryType)
            .Assert(() => idField.Name == "Id")
            .Assert(() => idField.Type == guidType);

            var assume1 = objectTheorem.ConstraintBuilder.Assume(() => categoryIdField.Type == stringType);

            // Assert
            var solved = objectTheorem.Solve();

            Assert.IsNotNull(solved);
            Assert.AreEqual(Status.Unsatisfiable, solved.Status);

            var assume1Result = solved.IsAssumptionWrong(assume1);

            Assert.IsTrue(assume1Result);
            objectTheorem.ConstraintBuilder.RemoveAssumption(assume1);

            solved = objectTheorem.Solve();
            Assert.IsNotNull(solved);
            Assert.AreEqual(Status.Satisfiable, solved.Status);

            ValueType Type1 = solved.GetValue(categoryIdField, f => f.Type);

            Assert.AreEqual(guidType, Type1);
        }
        public EFMetamodelInstantiation(IEnumerable <INamedTypeSymbol> entityTypeSymbols, ObjectTheoremContext objectTheorem,
                                        ClassAssumptions classAssumptions, PropertyAssumptions propertyAssumptions)
        {
            _entityTypeSymbols   = entityTypeSymbols;
            _objectTheorem       = objectTheorem;
            _constraintBuilder   = _objectTheorem.ConstraintBuilder;
            _propertyAssumptions = propertyAssumptions;

            _assumptionHandler = new AssumptionHandler(_constraintBuilder, classAssumptions, propertyAssumptions);
        }
        public void ForeignKeyTypeMatchRule_Unsuccessful_Satisfiable()
        {
            // Arrange
            var objectTheorem = new ObjectTheoremContext();

            objectTheorem.RegisterSuperType<Type>();
            objectTheorem.RegisterSuperType<Field>();
            objectTheorem.RegisterSuperType<ReferenceField>();

            var productType = objectTheorem.CreateInstance<ReferenceType>("ProductType");
            var categoryType = objectTheorem.CreateInstance<ReferenceType>("CategoryType");

            var stringType = objectTheorem.CreateInstance<ValueType>("StringType");
            var guidType = objectTheorem.CreateInstance<ValueType>("GuidType");

            var categoryField = objectTheorem.CreateInstance<SingleField>("CategoryField");
            var categoryIdField = objectTheorem.CreateInstance<ValueField>("CategoryIdField");
            var idField = objectTheorem.CreateInstance<ValueField>("IdField");

            objectTheorem.SetPossibleStringValues("ID", "Id", "CategoryId");

            // Act
            objectTheorem.ConstraintBuilder
                .Assert(() => categoryIdField.Type == idField.Type)

                .Assert(() => productType.SingleFields == new[] { categoryField })
                .Assert(() => categoryField.Owner == productType)
                .Assert(() => categoryField.Type == categoryType)
                .Assert(() => productType.ValueFields == new[] { categoryIdField })
                .Assert(() => categoryIdField.Owner == productType)
                .Assert(() => categoryIdField.Name == "CategoryId")
                .Assert(() => categoryType.ValueFields == new[] { idField })
                .Assert(() => idField.Owner == categoryType)
                .Assert(() => idField.Name == "Id")
                .Assert(() => idField.Type == guidType);

            var assume1 = objectTheorem.ConstraintBuilder.Assume(() => categoryIdField.Type == stringType);

            // Assert
            var solved = objectTheorem.Solve();
            Assert.IsNotNull(solved);
            Assert.AreEqual(Status.Unsatisfiable, solved.Status);

            var assume1Result = solved.IsAssumptionWrong(assume1);
            Assert.IsTrue(assume1Result);
            objectTheorem.ConstraintBuilder.RemoveAssumption(assume1);

            solved = objectTheorem.Solve();
            Assert.IsNotNull(solved);
            Assert.AreEqual(Status.Satisfiable, solved.Status);

            ValueType Type1 = solved.GetValue(categoryIdField, f => f.Type);
            Assert.AreEqual(guidType, Type1);
        }
Example #24
0
        public void IdKeyDiscoveryConvention_Successful_Satisfiable()
        {
            // Arrange
            var objectTheorem = new ObjectTheoremContext();

            objectTheorem.RegisterSuperType <Z3.ObjectTheorem.EF.Metamodel.Type>();
            var employeeType = objectTheorem.CreateInstance <ReferenceType>("EmployeeType");

            objectTheorem.RegisterSuperType <Field>();
            objectTheorem.SetPossibleStringValues("Id", "Name", "Income", "ID", "EmployeeTypeId", "EmployeeTypeID");
            var idField     = objectTheorem.CreateInstance <ValueField>("IdField");
            var nameField   = objectTheorem.CreateInstance <ValueField>("NameField");
            var incomeField = objectTheorem.CreateInstance <ValueField>("IncomeField");

            // Act
            EFConstraints.AddPrimayKeyRuleConstraints(objectTheorem.ConstraintBuilder);

            objectTheorem.ConstraintBuilder
            .Assert(() => employeeType.IsEntity == true)
            .Assert(() => employeeType.ValueFields == new[] { idField, nameField, incomeField })
            .Assert(() => idField.Name == "Id")
            .Assert(() => idField.Owner == employeeType)
            .Assert(() => nameField.Name == "Name")
            .Assert(() => nameField.Owner == employeeType)
            .Assert(() => incomeField.Name == "Income")
            .Assert(() => incomeField.Owner == employeeType);

            var assume1 = objectTheorem.ConstraintBuilder.Assume(() => idField.HasKeyAttribute == false);
            var assume2 = objectTheorem.ConstraintBuilder.Assume(() => nameField.HasKeyAttribute == false);
            var assume3 = objectTheorem.ConstraintBuilder.Assume(() => incomeField.HasKeyAttribute == false);

            // Assert
            var solved = objectTheorem.Solve();

            Assert.IsNotNull(solved);
            Assert.AreEqual(Status.Satisfiable, solved.Status);

            bool HasKeyAttribute1 = solved.GetValue(idField, i => i.HasKeyAttribute);
            bool HasKeyAttribute2 = solved.GetValue(nameField, i => i.HasKeyAttribute);
            bool HasKeyAttribute3 = solved.GetValue(incomeField, i => i.HasKeyAttribute);

            Assert.IsFalse(HasKeyAttribute1);
            Assert.IsFalse(HasKeyAttribute2);
            Assert.IsFalse(HasKeyAttribute3);

            bool IsPrimaryKey1 = solved.GetValue(idField, i => i.IsPrimaryKey);
            bool IsPrimaryKey2 = solved.GetValue(nameField, i => i.IsPrimaryKey);
            bool IsPrimaryKey3 = solved.GetValue(incomeField, i => i.IsPrimaryKey);

            Assert.IsTrue(IsPrimaryKey1);
            Assert.IsFalse(IsPrimaryKey2);
            Assert.IsFalse(IsPrimaryKey3);
        }
        public void EFMetaModel_WithRefPropsAndAssertAll_ShouldBe_Unsatisfiable()
        {
            // Arrange
            var objectTheorem = new ObjectTheoremContext();

            var typeInstance1 = objectTheorem.CreateInstance<Category>("TypeInstance1");
            var fieldInstance1 = objectTheorem.CreateInstance<Product>("FieldInstance1");

            // Act
            objectTheorem.ConstraintBuilder
                .AssertAll<Product>((f) => f.Category.IsHighlighted == true)
                .Assert(() => fieldInstance1.Category == typeInstance1)
                .Assert(() => typeInstance1.IsHighlighted == false);

            // Assert
            var solved = objectTheorem.Solve();
            Assert.IsNull(solved);
        }
        public void SM_WithStringProps_ShouldBe_Unsatisfiable()
        {
            // Arrange
            var objectTheorem = new ObjectTheoremContext();

            objectTheorem.SetPossibleStringValues("Hans", "Fred");

            var classWithStringA = objectTheorem.CreateInstance<ClassWithStringA>("ClassWithStringA");

            // Act
            objectTheorem.ConstraintBuilder
                .AssertAll<ClassWithStringA>(c => c.FirstName != "Hans")
                .Assert(() => "Fred" != classWithStringA.FirstName);

            // Assert
            var solved = objectTheorem.Solve();
            Assert.IsNull(solved);
        }
        public void SimpleModel_ShouldBe_NotSatisfiable()
        {
            // Arrange
            var objectTheorem = new ObjectTheoremContext();

            var classAInstance = objectTheorem.CreateInstance <ClassA>("ClassAInstance");
            var classBInstance = objectTheorem.CreateInstance <ClassB>("ClassBInstance");

            // Act
            objectTheorem.ConstraintBuilder
            .AssertAll <ClassA, ClassB>((a, b) => a.IsValidA == b.IsValidB)
            .Assert(() => classAInstance.IsValidA == true)
            .Assert(() => classBInstance.IsValidB == false);

            // Assert
            var solved = objectTheorem.Solve();

            Assert.IsNull(solved);
        }
        public void EFMetaModel_WithRefPropsAndAssertAll_ShouldBe_Unsatisfiable()
        {
            // Arrange
            var objectTheorem = new ObjectTheoremContext();

            var typeInstance1  = objectTheorem.CreateInstance <Category>("TypeInstance1");
            var fieldInstance1 = objectTheorem.CreateInstance <Product>("FieldInstance1");

            // Act
            objectTheorem.ConstraintBuilder
            .AssertAll <Product>((f) => f.Category.IsHighlighted == true)
            .Assert(() => fieldInstance1.Category == typeInstance1)
            .Assert(() => typeInstance1.IsHighlighted == false);

            // Assert
            var solved = objectTheorem.Solve();

            Assert.IsNull(solved);
        }
Example #29
0
        public void SM_WithStringProps_ShouldBe_Unsatisfiable()
        {
            // Arrange
            var objectTheorem = new ObjectTheoremContext();

            objectTheorem.SetPossibleStringValues("Hans", "Fred");

            var classWithStringA = objectTheorem.CreateInstance <ClassWithStringA>("ClassWithStringA");

            // Act
            objectTheorem.ConstraintBuilder
            .AssertAll <ClassWithStringA>(c => c.FirstName != "Hans")
            .Assert(() => "Fred" != classWithStringA.FirstName);

            // Assert
            var solved = objectTheorem.Solve();

            Assert.IsNull(solved);
        }
        public void EFMetaModel_WithRequiredAny_EmptyArray_ShouldBe_Unsatisfiable()
        {
            // Arrange
            var objectTheorem = new ObjectTheoremContext();

            var typeInstance1 = objectTheorem.CreateInstance <Category>("TypeInstance1");

            var fieldInstance1 = objectTheorem.CreateInstance <Product>("FieldInstance1");
            var fieldInstance2 = objectTheorem.CreateInstance <Product>("FieldInstance2");

            // Act
            objectTheorem.ConstraintBuilder
            .AssertAll <Category>(t => t.Products.Any(f1 => f1.IsPremiumOnly == true))
            .Assert(() => typeInstance1.Products == new Product[0]);

            // Assert
            var solved = objectTheorem.Solve();

            Assert.IsNull(solved);
        }
        public void EFMetaModel_WithRefPropsAndAssertAll_ShouldBe_Satisfiable()
        {
            // Arrange
            var objectTheorem = new ObjectTheoremContext();

            var typeInstance1 = objectTheorem.CreateInstance<Category>("TypeInstance1");
            var fieldInstance1 = objectTheorem.CreateInstance<Product>("FieldInstance1");

            // Act
            objectTheorem.ConstraintBuilder
                .AssertAll<Product>((f) => f.Category.IsHighlighted == true)
                .Assert(() => fieldInstance1.Category == typeInstance1);

            // Assert
            var solved = objectTheorem.Solve();
            Assert.IsNotNull(solved);

            bool IsEntity1 = solved.GetValue(typeInstance1, i => i.IsHighlighted);
            Assert.IsTrue(IsEntity1);
        }
        public void EFMetaModel_WithAllOneRequiredItemInList_ShouldBe_Satisfiable()
        {
            // Arrange
            var objectTheorem = new ObjectTheoremContext();

            var typeInstance1 = objectTheorem.CreateInstance<Category>("TypeInstance1");

            var fieldInstance1 = objectTheorem.CreateInstance<Product>("FieldInstance1");

            // Act
            objectTheorem.ConstraintBuilder
                    .AssertAll<Category>(t => t.Products == new []{ fieldInstance1 });

            // Assert
            var solved = objectTheorem.Solve();
            Assert.IsNotNull(solved);

            System.Collections.Generic.IEnumerable<Product> products1 = solved.GetValue(typeInstance1, i => i.Products);
            CollectionAssert.AreEquivalent(new[] { fieldInstance1 }, products1.ToList());
        }
        public void EFMetaModel_WithRequiredEmptyArray_ShouldBe_Satisfiable()
        {
            // Arrange
            var objectTheorem = new ObjectTheoremContext();

            var typeInstance1 = objectTheorem.CreateInstance<Category>("TypeInstance1");

            var fieldInstance1 = objectTheorem.CreateInstance<Product>("FieldInstance1");

            // Act
            objectTheorem.ConstraintBuilder
                    .Assert(() => typeInstance1.Products == new Product[0]);

            // Assert
            var solved = objectTheorem.Solve();
            Assert.IsNotNull(solved);

            System.Collections.Generic.IEnumerable<Product> products1 = solved.GetValue(typeInstance1, i => i.Products);
            Assert.AreEqual(0, products1.Count());
        }
        public void EFMetaModel_WithAllOneRequiredItemInList_ShouldBe_Satisfiable()
        {
            // Arrange
            var objectTheorem = new ObjectTheoremContext();

            var typeInstance1 = objectTheorem.CreateInstance <Category>("TypeInstance1");

            var fieldInstance1 = objectTheorem.CreateInstance <Product>("FieldInstance1");

            // Act
            objectTheorem.ConstraintBuilder
            .AssertAll <Category>(t => t.Products == new [] { fieldInstance1 });

            // Assert
            var solved = objectTheorem.Solve();

            Assert.IsNotNull(solved);

            System.Collections.Generic.IEnumerable <Product> products1 = solved.GetValue(typeInstance1, i => i.Products);
            CollectionAssert.AreEquivalent(new[] { fieldInstance1 }, products1.ToList());
        }
        public void EFMetaModel_WithRequiredEmptyArray_ShouldBe_Satisfiable()
        {
            // Arrange
            var objectTheorem = new ObjectTheoremContext();

            var typeInstance1 = objectTheorem.CreateInstance <Category>("TypeInstance1");

            var fieldInstance1 = objectTheorem.CreateInstance <Product>("FieldInstance1");

            // Act
            objectTheorem.ConstraintBuilder
            .Assert(() => typeInstance1.Products == new Product[0]);

            // Assert
            var solved = objectTheorem.Solve();

            Assert.IsNotNull(solved);

            System.Collections.Generic.IEnumerable <Product> products1 = solved.GetValue(typeInstance1, i => i.Products);
            Assert.AreEqual(0, products1.Count());
        }
Example #36
0
        public void IndexRule_Unsuccessful_Satisfiable()
        {
            // Arrange
            var objectTheorem = new ObjectTheoremContext();

            objectTheorem.RegisterSuperType <Type>();
            objectTheorem.RegisterSuperType <Field>();

            var valueField1 = objectTheorem.CreateInstance <ValueField>("ValueField1");

            var stringType = objectTheorem.CreateInstance <ValueType>("StringType");

            // Act
            EFConstraints.AddIndexRuleConstraints(objectTheorem.ConstraintBuilder, stringType);

            objectTheorem.ConstraintBuilder
            .Assert(() => valueField1.Type == stringType);

            var assume1 = objectTheorem.ConstraintBuilder.Assume(() => valueField1.HasIndexAttribute == true);
            var assume2 = objectTheorem.ConstraintBuilder.Assume(() => valueField1.HasMaxLengthAttribute == false);

            // Assert
            var solved = objectTheorem.Solve();

            Assert.IsNotNull(solved);
            Assert.AreEqual(Status.Unsatisfiable, solved.Status);

            var assume1Result = solved.IsAssumptionWrong(assume1);

            Assert.IsTrue(assume1Result);
            objectTheorem.ConstraintBuilder.RemoveAssumption(assume1);

            solved = objectTheorem.Solve();
            Assert.IsNotNull(solved);
            Assert.AreEqual(Status.Satisfiable, solved.Status);

            bool HasComplexTypeAttribute = solved.GetValue(valueField1, i => i.HasIndexAttribute);

            Assert.IsFalse(HasComplexTypeAttribute);
        }
        public void EnumValues_ShouldBe_Satisfiable2()
        {
            // Arrange
            var objectTheorem = new ObjectTheoremContext();

            var classAInstance1 = objectTheorem.CreateInstance<ClassA>("ClassAInstance");
            var classAInstance2 = objectTheorem.CreateInstance<ClassA>("ClassBInstance");

            // Act
            objectTheorem.ConstraintBuilder
                    .Assert(() => classAInstance1.Color != classAInstance2.Color)
                    .Assert(() => classAInstance1.Color == Colors.Black);

            // Assert
            var solved = objectTheorem.Solve();
            Assert.IsNotNull(solved);

            Colors color1 = solved.GetValue(classAInstance1, i => i.Color);
            Colors color2 = solved.GetValue(classAInstance2, i => i.Color);
            Assert.IsTrue(color1 != color2);
            Assert.AreEqual(Colors.Black, color1);
        }
        public void NotMappedRule_Successful_Satisfiable()
        {
            // Arrange
            var objectTheorem = new ObjectTheoremContext();

            objectTheorem.RegisterSuperType <Type>();
            objectTheorem.RegisterSuperType <Field>();
            objectTheorem.RegisterSuperType <ReferenceField>();

            var customerType = objectTheorem.CreateInstance <ReferenceType>("Customer1");
            var addressType  = objectTheorem.CreateInstance <ReferenceType>("Address1");

            var arrayOfAddressField = objectTheorem.CreateInstance <CollectionField>("AddressField");
            var namesField          = objectTheorem.CreateInstance <ValueField>("NamesField");

            var arrayOfStringType = objectTheorem.CreateInstance <ValueType>("CollectionOfStringType");

            // Act
            EFConstraints.AddNotMappedRuleConstraints(objectTheorem.ConstraintBuilder, new[] { arrayOfStringType });

            objectTheorem.ConstraintBuilder
            .Assert(() => customerType.ValueFields == new[] { namesField })
            .Assert(() => namesField.Owner == customerType)
            .Assert(() => namesField.Type == arrayOfStringType)
            .Assert(() => customerType.CollectionFields == new[] { arrayOfAddressField })
            .Assert(() => arrayOfAddressField.Owner == customerType)
            .Assert(() => arrayOfAddressField.Type == addressType)
            .Assert(() => addressType.HasComplexTypeAttribute == true);

            var assume1 = objectTheorem.ConstraintBuilder.Assume(() => arrayOfAddressField.HasNotMappedAttribute == true);
            var assume2 = objectTheorem.ConstraintBuilder.Assume(() => namesField.HasNotMappedAttribute == true);

            // Assert
            var solved = objectTheorem.Solve();

            Assert.IsNotNull(solved);
            Assert.AreEqual(Status.Satisfiable, solved.Status);
        }
        public void EFMetaModel_WithAny_TwoItemArray_ShouldBe_Unsatisfiable()
        {
            // Arrange
            var objectTheorem = new ObjectTheoremContext();

            var typeInstance1 = objectTheorem.CreateInstance<Category>("TypeInstance1");

            var fieldInstance1 = objectTheorem.CreateInstance<Product>("FieldInstance1");
            var fieldInstance2 = objectTheorem.CreateInstance<Product>("FieldInstance2");

            // Act
            objectTheorem.ConstraintBuilder
                    .AssertAll<Category>(t => t.Products.Any(f1 => f1.IsPremiumOnly == true))
                    .Assert(() => typeInstance1.Products == new[] { fieldInstance1, fieldInstance2 })
                    .Assert(() => fieldInstance1.Category == typeInstance1)
                    .Assert(() => fieldInstance2.Category == typeInstance1)
                    .Assert(() => fieldInstance1.IsPremiumOnly == false)
                    .Assert(() => fieldInstance2.IsPremiumOnly == false);

            // Assert
            var solved = objectTheorem.Solve();
            Assert.IsNull(solved);
        }
        public void IndexRule_Unsuccessful_Satisfiable()
        {
            // Arrange
            var objectTheorem = new ObjectTheoremContext();

            objectTheorem.RegisterSuperType<Type>();
            objectTheorem.RegisterSuperType<Field>();

            var valueField1 = objectTheorem.CreateInstance<ValueField>("ValueField1");

            var stringType = objectTheorem.CreateInstance<ValueType>("StringType");

            // Act
            EFConstraints.AddIndexRuleConstraints(objectTheorem.ConstraintBuilder, stringType);

            objectTheorem.ConstraintBuilder
                .Assert(() => valueField1.Type == stringType);

            var assume1 = objectTheorem.ConstraintBuilder.Assume(() => valueField1.HasIndexAttribute == true);
            var assume2 = objectTheorem.ConstraintBuilder.Assume(() => valueField1.HasMaxLengthAttribute == false);

            // Assert
            var solved = objectTheorem.Solve();
            Assert.IsNotNull(solved);
            Assert.AreEqual(Status.Unsatisfiable, solved.Status);

            var assume1Result = solved.IsAssumptionWrong(assume1);
            Assert.IsTrue(assume1Result);
            objectTheorem.ConstraintBuilder.RemoveAssumption(assume1);

            solved = objectTheorem.Solve();
            Assert.IsNotNull(solved);
            Assert.AreEqual(Status.Satisfiable, solved.Status);

            bool HasComplexTypeAttribute = solved.GetValue(valueField1, i => i.HasIndexAttribute);
            Assert.IsFalse(HasComplexTypeAttribute);
        }
        public void DatabaseGeneratedRule_Successful_Satisfiable()
        {
            // Arrange
            var objectTheorem = new ObjectTheoremContext();

            objectTheorem.RegisterSuperType <Type>();
            var employeeType = objectTheorem.CreateInstance <ReferenceType>("EmployeeType");

            objectTheorem.RegisterSuperType <Field>();
            objectTheorem.SetPossibleStringValues("Id", "ID", "EmployeeTypeId", "EmployeeTypeID");
            var idField = objectTheorem.CreateInstance <ValueField>("IdField");

            var stringType = objectTheorem.CreateInstance <ValueType>("StringType");
            var numberType = objectTheorem.CreateInstance <ValueType>("NumberType");
            var guidType   = objectTheorem.CreateInstance <ValueType>("GuidType");

            // Act
            EFConstraints.AddPrimayKeyRuleConstraints(objectTheorem.ConstraintBuilder);
            EFConstraints.AddDatabaseGeneratedRuleConstraints(objectTheorem.ConstraintBuilder, stringType, numberType, guidType);

            objectTheorem.ConstraintBuilder
            .Assert(() => employeeType.IsEntity == true)
            .Assert(() => employeeType.ValueFields == new[] { idField })
            .Assert(() => idField.Name == "Id")
            .Assert(() => idField.Owner == employeeType)
            .Assert(() => idField.Type == numberType)
            .Assert(() => idField.DatabaseGeneratedAttribute == DatabaseGeneratedAttribute.None);

            var assume1 = objectTheorem.ConstraintBuilder.Assume(() => idField.DatabaseGeneratedAttribute == DatabaseGeneratedAttribute.None);

            // Assert
            var solved = objectTheorem.Solve();

            Assert.IsNotNull(solved);
            Assert.AreEqual(Status.Satisfiable, solved.Status);
        }
        public static void AddAll(ObjectTheoremContext _objectTheorem, IEnumerable<KeyValuePair<string, Metamodel.Type>> createdTypes)
        {
            var stringType = (ValueType)createdTypes.Single(i => i.Key == "StringValueType").Value;
            var numberType = (ValueType)createdTypes.Single(i => i.Key == "Int32ValueType").Value;
            var guidType = (ValueType)createdTypes.Single(i => i.Key == "GuidValueType").Value;
            var collectionsOfValueType = createdTypes
                .Where(t => t.Value is ValueType && t.Key.StartsWith("Collection"))
                .Select(t => t.Value)
                .Cast<ValueType>();

            _objectTheorem.SetPossibleStringValues(new[] { "ID", "Id", "-" });

            var constraintBuilder = _objectTheorem.ConstraintBuilder;

            AddPrimayKeyRuleConstraints(constraintBuilder);
            AddDatabaseGeneratedRuleConstraints(constraintBuilder, stringType, numberType, guidType);
            AddComplexTypeRuleConstraints(constraintBuilder);
            AddIndexRuleConstraints(constraintBuilder, stringType);
            AddNotMappedRuleConstraints(constraintBuilder, collectionsOfValueType);

            //constraintBuilder
            //    .AssertAll<SingleField>(sf => sf.Owner.ValueFields.Any(vf => vf.Name == sf.ForeignKeyAttribute && vf.ForeignType == sf.Type))
            //    .AssertAll<ValueField>(vf => vf.ForeignType.ValueFields.Any(vf2 => vf2.IsPrimaryKey && vf2.Type == vf.Type));
        }
        public static void AddAll(ObjectTheoremContext _objectTheorem, IEnumerable <KeyValuePair <string, Metamodel.Type> > createdTypes)
        {
            var stringType             = (ValueType)createdTypes.Single(i => i.Key == "StringValueType").Value;
            var numberType             = (ValueType)createdTypes.Single(i => i.Key == "Int32ValueType").Value;
            var guidType               = (ValueType)createdTypes.Single(i => i.Key == "GuidValueType").Value;
            var collectionsOfValueType = createdTypes
                                         .Where(t => t.Value is ValueType && t.Key.StartsWith("Collection"))
                                         .Select(t => t.Value)
                                         .Cast <ValueType>();

            _objectTheorem.SetPossibleStringValues(new[] { "ID", "Id", "-" });

            var constraintBuilder = _objectTheorem.ConstraintBuilder;

            AddPrimayKeyRuleConstraints(constraintBuilder);
            AddDatabaseGeneratedRuleConstraints(constraintBuilder, stringType, numberType, guidType);
            AddComplexTypeRuleConstraints(constraintBuilder);
            AddIndexRuleConstraints(constraintBuilder, stringType);
            AddNotMappedRuleConstraints(constraintBuilder, collectionsOfValueType);

            //constraintBuilder
            //    .AssertAll<SingleField>(sf => sf.Owner.ValueFields.Any(vf => vf.Name == sf.ForeignKeyAttribute && vf.ForeignType == sf.Type))
            //    .AssertAll<ValueField>(vf => vf.ForeignType.ValueFields.Any(vf2 => vf2.IsPrimaryKey && vf2.Type == vf.Type));
        }
Example #44
0
 public EFRoslynTheorem()
 {
     _classAssumptions    = new ClassAssumptions();
     _propertyAssumptions = new PropertyAssumptions();
     _objectTheorem       = new ObjectTheoremContext();
 }
        public void ForeignKeyDiscoveryConvention_Successful_Satisfiable()
        {
            // Arrange
            var objectTheorem = new ObjectTheoremContext();

            objectTheorem.RegisterSuperType <Type>();
            objectTheorem.RegisterSuperType <Field>();
            objectTheorem.RegisterSuperType <ReferenceField>();

            var nullType = objectTheorem.CreateInstance <ReferenceType>("NullType");

            var categoryType    = objectTheorem.CreateInstance <ReferenceType>("CategoryType");
            var categoryIdField = objectTheorem.CreateInstance <ValueField>("CategoryIdField");

            var productType    = objectTheorem.CreateInstance <ReferenceType>("ProductType");
            var productIdField = objectTheorem.CreateInstance <ValueField>("ProductIdField");

            var productCategoryIdField = objectTheorem.CreateInstance <ValueField>("productCategoryIdField");
            var productCategoryField   = objectTheorem.CreateInstance <SingleField>("productCategoryField");

            var stringType = objectTheorem.CreateInstance <ValueType>("StringType");
            var numberType = objectTheorem.CreateInstance <ValueType>("NumberType");
            var guidType   = objectTheorem.CreateInstance <ValueType>("GuidType");

            objectTheorem.SetPossibleStringValues("CatId", "ProdId", "CategoryId", "Category", "-");

            // Act
            objectTheorem.ConstraintBuilder
            .AssertAll <SingleField>(sf => sf.Owner.ValueFields.Any(vf => vf.Name == sf.ForeignKeyAttribute && vf.ForeignType == sf.Type))
            .AssertAll <ValueField>(vf => vf.ForeignType == nullType ^ vf.ForeignType.ValueFields.Any(vf2 => vf2.IsPrimaryKey && vf2.Type == vf.Type))

            .Assert(() => categoryIdField.Owner == categoryType)
            .Assert(() => categoryIdField.Name == "CatId")
            .Assert(() => categoryIdField.Type == stringType)
            .Assert(() => categoryIdField.IsPrimaryKey == true)
            .Assert(() => categoryType.ValueFields == new[] { categoryIdField })

            .Assert(() => productIdField.Owner == productType)
            .Assert(() => productIdField.Name == "ProdId")
            .Assert(() => productIdField.Type == guidType)
            .Assert(() => productIdField.IsPrimaryKey == true)
            .Assert(() => productCategoryIdField.Owner == productType)
            .Assert(() => productCategoryIdField.Name == "CategoryId")
            .Assert(() => productCategoryIdField.Type == stringType)
            .Assert(() => productCategoryField.Owner == productType)
            .Assert(() => productCategoryField.Name == "Category")
            .Assert(() => productCategoryField.Type == categoryType)
            .Assert(() => productType.ValueFields == new[] { productIdField, productCategoryIdField })
            .Assert(() => productType.SingleFields == new[] { productCategoryField });

            var assume1 = objectTheorem.ConstraintBuilder.Assume(() => productCategoryField.ForeignKeyAttribute == "CategoryId");

            // Assert
            var solved = objectTheorem.Solve();

            Assert.IsNotNull(solved);
            Assert.AreEqual(Status.Satisfiable, solved.Status);

            var test = solved.GetValue(productCategoryIdField, p => p.Type);

            Assert.AreEqual(stringType, test);
        }
        public void SimpleModel_ShouldBe_NotSatisfiable()
        {
            // Arrange
            var objectTheorem = new ObjectTheoremContext();

            var classAInstance = objectTheorem.CreateInstance<ClassA>("ClassAInstance");
            var classBInstance = objectTheorem.CreateInstance<ClassB>("ClassBInstance");

            // Act
            objectTheorem.ConstraintBuilder
                    .AssertAll<ClassA, ClassB>((a, b) => a.IsValidA == b.IsValidB)
                    .Assert(() => classAInstance.IsValidA == true)
                    .Assert(() => classBInstance.IsValidB == false);

            // Assert
            var solved = objectTheorem.Solve();
            Assert.IsNull(solved);
        }
        // TODO: results in UNKNOWN
        //[TestMethod]
        public void EFMetaModel_WithOptionalAny_EmptyArray_ShouldBe_Satisfiable()
        {
            // Arrange
            var objectTheorem = new ObjectTheoremContext();

            var typeInstance1 = objectTheorem.CreateInstance<Category>("TypeInstance1");

            var fieldInstance1 = objectTheorem.CreateInstance<Product>("FieldInstance1");
            var fieldInstance2 = objectTheorem.CreateInstance<Product>("FieldInstance2");

            // Act
            objectTheorem.ConstraintBuilder
                    .AssertAll<Category>(t => t.Products == new Product[0] || t.Products.Any(f1 => f1.IsPremiumOnly == true))
                    .Assert(() => typeInstance1.Products == new Product[0]);

            // Assert
            var solved = objectTheorem.Solve();
            Assert.IsNotNull(solved);
        }
 public EFRoslynTheorem()
 {
     _classAssumptions = new ClassAssumptions();
     _propertyAssumptions = new PropertyAssumptions();
     _objectTheorem = new ObjectTheoremContext();
 }
        public void SimpleModel_OutsideConstant_ShouldBe_Satisfiable()
        {
            // Arrange
            var objectTheorem = new ObjectTheoremContext();

            var outsideBoolConstant = true;

            var classAInstance = objectTheorem.CreateInstance<ClassA>("ClassAInstance");
            var classBInstance = objectTheorem.CreateInstance<ClassB>("ClassBInstance");

            // Act
            objectTheorem.ConstraintBuilder
                    .AssertAll<ClassA, ClassB>((a, b) => a.IsValidA == b.IsValidB)
                    .Assert(() => classAInstance.IsValidA == outsideBoolConstant);

            // Assert
            var solved = objectTheorem.Solve();
            Assert.IsNotNull(solved);

            bool isValidA = solved.GetValue(classAInstance, i => i.IsValidA);
            bool isValidB = solved.GetValue(classBInstance, i => i.IsValidB);
            Assert.IsTrue(isValidA);
            Assert.IsTrue(isValidB);
        }