C# Product.CreateProperty方法代码示例

        public void when_creating_component_named_as_property_then_throws()
        {
            var product = new Product("Foo", "IFoo");
            product.CreateProperty("Element");

            Assert.Throws<ArgumentException>(() => product.CreateElement("Element", "IElement"));
        }

        public void when_visiting_root_then_visits_entire_graph()
        {
            var products = 0;
            var elements = 0;
            var collections = 0;
            var containers = 0;
            var components = 0;
            var properties = 0;

            var visitor = InstanceVisitor.Create(
                p => products++,
                e => elements++,
                c => collections++,
                c => containers++,
                c => components++,
                p => properties++);

            var product = new Product("Foo", "IFoo");
            product.CreateElement("Element", "IElement")
                .CreateProperty("IsVisible");
            product.CreateCollection("Collection", "ICollection")
                .CreateElement("Element", "IElement");
            product.CreateProperty("IsVisible");

            product.Accept(visitor);

            Assert.Equal(1, products);
            Assert.Equal(2, elements);
            Assert.Equal(1, collections);
            Assert.Equal(4, containers);
            Assert.Equal(4, components);
            Assert.Equal(2, properties);
        }

        public void when_mapping_product_then_does_not_remove_underscore_properties()
        {
            var toolkit = new ToolkitSchema("Toolkit", "1.0");
            var schema = toolkit.CreateProductSchema("IProduct");

            var product = new Product("Product", "IProduct");
            product.CreateProperty("_IsVisible").Value = true;

            ComponentMapper.SyncProduct(product, (IProductInfo)schema);

            Assert.NotNull(product.Schema);
            Assert.Equal(1, product.Properties.Count());
            Assert.Equal("_IsVisible", product.Properties.First().Name);
            Assert.True((bool)product.Properties.First().Value);
        }

        public void when_creating_property_then_it_has_schema()
        {
            var product = new Product("Foo", "IFoo");
            var info = Mock.Of<IProductInfo>(x =>
                x.Toolkit.Id == "Test" &&
                x.Toolkit.Version == "1.0" &&
                x.SchemaId == "IFoo" &&
                x.Properties == new []
                {
                    Mock.Of<IPropertyInfo>(p => p.Name == "IsPublic" && p.PropertyType == typeof(bool))
                });

            product.Schema = info;

            var prop = product.CreateProperty("IsPublic");

            Assert.NotNull(prop.Schema);
        }

        public void when_property_set_to_same_existing_value_then_does_not_raise_propertychanged()
        {
            var product = new Product("Product", "IProduct");
            product.CreateProperty("key").Value = "foo";

            var changed = default(PropertyChangeEventArgs);

            product.Events.PropertyChanged += (sender, args) => changed = args;

            product.Set("key", "foo");

            Assert.Null(changed);
        }

        public void when_property_changing_then_notifies_component()
        {
            var product = new Product("Product", "IProduct");
            product.CreateProperty("key").Value = "foo";

            var changing = default(PropertyChangeEventArgs);

            product.Events.PropertyChanging += (sender, args) => changing = args;

            product.Set("key", "bar");

            Assert.NotNull(changing);
            Assert.Equal("key", changing.PropertyName);
            Assert.Equal("foo", changing.OldValue);
            Assert.Equal("bar", changing.NewValue);
        }

        public void when_element_new_name_is_duplicated_with_container_property_then_throws()
        {
            var product = new Product("Foo", "IFoo");
            product.CreateProperty("Element");

            var child = product.CreateElement("Storage", "IStorage");

            Assert.Throws<ArgumentException>(() => child.Name = "Element");
        }

        public void when_deleting_property_then_removes_from_owner()
        {
            var product = new Product("Foo", "IFoo");
            var prop = product.CreateProperty("IsPublic");

            prop.Delete();

            Assert.Equal(0, product.Properties.Count());
        }

        public void when_deleting_property_then_owner_becomes_null()
        {
            var product = new Product("Foo", "IFoo");
            var prop = product.CreateProperty("IsPublic");

            prop.Delete();

            Assert.Null(prop.Owner);
        }

        public void when_creating_property_then_owner_properties_contains_new_property()
        {
            var product = new Product("Foo", "IFoo");

            var prop = product.CreateProperty("IsPublic");

            Assert.Same(prop, product.Properties.FirstOrDefault());
        }

        public void when_creating_property_then_owner_is_parent()
        {
            var product = new Product("Foo", "IFoo");

            var prop = product.CreateProperty("IsPublic");

            Assert.Same(product, prop.Owner);
        }

        public void when_creating_name_property_then_throws_because_its_intrinsic()
        {
            var product = new Product("Foo", "IFoo");

            Assert.Throws<ArgumentException>(() => product.CreateProperty("Name"));
        }

        public void when_creating_duplicate_property_then_throws()
        {
            var product = new Product("Foo", "IFoo");
            var prop = product.CreateProperty("IsPublic");

            Assert.Throws<ArgumentException>(() => product.CreateProperty("IsPublic"));
        }

        public void when_mapping_product_then_maps_property_schema()
        {
            var toolkit = new ToolkitSchema("Toolkit", "1.0");
            var schema = toolkit.CreateProductSchema("IProduct");
            schema.CreatePropertySchema("IsPublic", typeof(bool));

            var product = new Product("Product", "IProduct");
            product.CreateProperty("IsPublic").Value = true;

            ComponentMapper.SyncProduct(product, (IProductInfo)schema);

            Assert.NotNull(product.Schema);
            Assert.NotNull(product.Properties.First().Schema);
        }

        public void when_mapping_product_then_removes_properties_that_dont_exist_in_schema()
        {
            var toolkit = new ToolkitSchema("Toolkit", "1.0");
            var schema = toolkit.CreateProductSchema("IProduct");
            schema.CreatePropertySchema("IsPublic", typeof(bool));

            var product = new Product("Product", "IProduct");
            product.CreateProperty("IsVisible").Value = true;

            ComponentMapper.SyncProduct(product, (IProductInfo)schema);

            Assert.NotNull(product.Schema);
            Assert.Equal(1, product.Properties.Count());
            Assert.Equal("IsPublic", product.Properties.First().Name);
            Assert.False((bool)product.Properties.First().Value);
        }