public void AppendComparison_creates_parameters_and_adds_AND_for_multiple_comparisons()
        {
            var parameters = new EntityCommand().Parameters;

            var filterBuilder =
                EntityStoreSchemaQueryGenerator.AppendComparison(
                    new StringBuilder(),
                    "alias1",
                    "propertyName1",
                    "Value1",
                    parameters);

            EntityStoreSchemaQueryGenerator.AppendComparison(
                filterBuilder,
                "alias2",
                "propertyName2",
                "Value2",
                parameters);

            Assert.Equal(
                "alias1.propertyName1 LIKE @p0 AND alias2.propertyName2 LIKE @p1",
                filterBuilder.ToString());

            Assert.Equal(2, parameters.Count);
            Assert.Equal("p0,p1", string.Join(",", parameters.OfType <EntityParameter>().Select(p => p.ParameterName)));
            Assert.Equal("Value1,Value2", string.Join(",", parameters.OfType <EntityParameter>().Select(p => p.Value)));
        }
        public void Where_clause_created_when_Allow_and_Exclude_present()
        {
            var parameters = new EntityCommand().Parameters;

            Assert.Equal(
                "NOT ((alias.Name LIKE @p0) OR (alias.Name LIKE @p1))",
                new EntityStoreSchemaQueryGenerator(
                    string.Empty,
                    string.Empty,
                    EntityStoreSchemaFilterObjectTypes.Table,
                    new[]
            {
                new EntityStoreSchemaFilterEntry(
                    null,
                    null,
                    "nameAllowed",
                    EntityStoreSchemaFilterObjectTypes.Table,
                    EntityStoreSchemaFilterEffect.Exclude),
                new EntityStoreSchemaFilterEntry(
                    null,
                    null,
                    "nameExcluded",
                    EntityStoreSchemaFilterObjectTypes.Table,
                    EntityStoreSchemaFilterEffect.Exclude)
            },
                    new[] { "alias" })
                .CreateWhereClause(parameters).ToString());

            Assert.Equal(2, parameters.Count);
            Assert.Equal("p0,p1", string.Join(",", parameters.OfType <EntityParameter>().Select(p => p.ParameterName)));
            Assert.Equal("nameAllowed,nameExcluded", string.Join(",", parameters.OfType <EntityParameter>().Select(p => p.Value)));
        }
        public void Where_clause_created_for_single_Exclude_filter()
        {
            var parameters = new EntityCommand().Parameters;

            Assert.Equal(
                "NOT ((alias.CatalogName LIKE @p0 AND alias.SchemaName LIKE @p1 AND alias.Name LIKE @p2))",
                new EntityStoreSchemaQueryGenerator(
                    string.Empty,
                    string.Empty,
                    EntityStoreSchemaFilterObjectTypes.Table,
                    new[]
            {
                new EntityStoreSchemaFilterEntry(
                    "catalog",
                    "schema",
                    "name",
                    EntityStoreSchemaFilterObjectTypes.Table,
                    EntityStoreSchemaFilterEffect.Exclude)
            },
                    new[] { "alias" })
                .CreateWhereClause(parameters).ToString());

            Assert.Equal(3, parameters.Count);
            Assert.Equal("p0,p1,p2", string.Join(",", parameters.OfType <EntityParameter>().Select(p => p.ParameterName)));
            Assert.Equal("catalog,schema,name", string.Join(",", parameters.OfType <EntityParameter>().Select(p => p.Value)));
        }
        public void Where_clause_uses_AND_to_connect_multiple_aliases_and_Exclude_filter()
        {
            var parameters = new EntityCommand().Parameters;

            Assert.Equal(
                "NOT ((alias1.Name LIKE @p0))\r\nAND\r\nNOT ((alias2.Name LIKE @p1))",
                new EntityStoreSchemaQueryGenerator(
                    string.Empty,
                    string.Empty,
                    EntityStoreSchemaFilterObjectTypes.Table,
                    new[]
            {
                new EntityStoreSchemaFilterEntry(
                    null,
                    null,
                    "name",
                    EntityStoreSchemaFilterObjectTypes.Table,
                    EntityStoreSchemaFilterEffect.Exclude),
            },
                    new[] { "alias1", "alias2" })
                .CreateWhereClause(parameters).ToString());

            Assert.Equal(2, parameters.Count);
            Assert.Equal("p0,p1", string.Join(",", parameters.OfType <EntityParameter>().Select(p => p.ParameterName)));
            Assert.Equal("name,name", string.Join(",", parameters.OfType <EntityParameter>().Select(p => p.Value)));
        }
        public void AppendFilterEntry_uses_OR_to_connect_multiple_filters()
        {
            var parameters    = new EntityCommand().Parameters;
            var filterBuilder = new StringBuilder();

            EntityStoreSchemaQueryGenerator.AppendFilterEntry(
                filterBuilder,
                "alias",
                new EntityStoreSchemaFilterEntry(null, null, null),
                parameters);

            EntityStoreSchemaQueryGenerator.AppendFilterEntry(
                filterBuilder,
                "alias",
                new EntityStoreSchemaFilterEntry("catalog", "schema", null),
                parameters);

            Assert.Equal(
                "(alias.Name LIKE @p0) OR (alias.CatalogName LIKE @p1 AND alias.SchemaName LIKE @p2)",
                filterBuilder.ToString());

            Assert.Equal(3, parameters.Count);
            Assert.Equal("p0,p1,p2", string.Join(",", parameters.OfType <EntityParameter>().Select(p => p.ParameterName)));
            Assert.Equal("%,catalog,schema", string.Join(",", parameters.OfType <EntityParameter>().Select(p => p.Value)));
        }