示例#1
0
        public void Matches_MdxQueryAndSlighltyDifferentQueryWithCorrectSettings_NotMatching()
        {
            //Buiding object used during test
            var mdx = "WITH MEMBER [Measures].NewAmount AS [Measures].[Amount]+1";

            mdx += " SELECT [Measures].NewAmount ON 0, NON EMPTY([Date].[Calendar].[Calendar Year]) ON 1 FROM [Adventure Works]";
            var expectedQuery = new NBi.Core.Query.Query(mdx, ConnectionStringReader.GetAdomd());
            var resolver      = new FakeQueryResultSetResolver(expectedQuery, serviceLocator);
            var builder       = new ResultSetServiceBuilder();

            builder.Setup(resolver);
            var ctr = new EqualToConstraint(builder.GetService());

            ctr.Using(new SettingsOrdinalResultSet(
                          SettingsOrdinalResultSet.KeysChoice.First,
                          SettingsOrdinalResultSet.ValuesChoice.Last,
                          NumericAbsoluteTolerance.None)
                      );

            var mdx2  = "SELECT [Measures].[Amount] ON 0, ([Date].[Calendar].[Calendar Year]-[Date].[Calendar].[Calendar Year].&[2010]) ON 1  FROM [Adventure Works]";
            var query = new NBi.Core.Query.Query(mdx2, ConnectionStringReader.GetAdomd());

            var actualBuilder = new ResultSetServiceBuilder();

            actualBuilder.Setup(new FakeQueryResultSetResolver(query, serviceLocator));
            var actual = actualBuilder.GetService();

            //Assertion
            Assert.That(ctr.Matches(actual), Is.False);
        }
示例#2
0
        public void Matches_MdxQueryWithNullComparedToSqlWithNull_Matching()
        {
            //Buiding object used during test
            var expectedQuery = "SELECT 'CY 2010',  NULL ";

            var expectedCmd = new SqlCommand(expectedQuery, new SqlConnection(ConnectionStringReader.GetSqlClient()));
            var resolver    = new FakeQueryResultSetLoader(expectedCmd);
            var builder     = new ResultSetServiceBuilder();

            builder.Setup(resolver);
            var ctr = new EqualToConstraint(builder.GetService());

            ctr.Using(
                new SettingsIndexResultSet(
                    SettingsIndexResultSet.KeysChoice.AllExpectLast,
                    SettingsIndexResultSet.ValuesChoice.Last,
                    NumericAbsoluteTolerance.None
                    )
                );

            var query = "SELECT  [Measures].[Amount] ON 0, [Date].[Calendar].[Calendar Year].&[2010] ON 1 FROM [Adventure Works]";
            var cmd   = new AdomdCommand(query, new AdomdConnection(ConnectionStringReader.GetAdomd()));

            var actualBuilder = new ResultSetServiceBuilder();

            actualBuilder.Setup(new FakeQueryResultSetLoader(cmd));
            var actual = actualBuilder.GetService();

            //Assertion
            Assert.That(ctr.Matches(actual));
        }
        public void Matches_MdxQueryAndSlighltyDifferentQueryWithCorrectSettings_NotMatching()
        {
            //Buiding object used during test
            var expectedQuery = "WITH MEMBER [Measures].NewAmount AS [Measures].[Amount]+1";

            expectedQuery += " SELECT [Measures].NewAmount ON 0, NON EMPTY([Date].[Calendar].[Calendar Year]) ON 1 FROM [Adventure Works]";
            var expectedCmd = new AdomdCommand(expectedQuery, new AdomdConnection(ConnectionStringReader.GetAdomd()));

            var ctr = new EqualToConstraint(expectedCmd);

            ctr.Using(new SettingsResultSetComparisonByIndex(
                          SettingsResultSetComparisonByIndex.KeysChoice.First,
                          SettingsResultSetComparisonByIndex.ValuesChoice.Last,
                          NumericAbsoluteTolerance.None)
                      );

            var query = "SELECT [Measures].[Amount] ON 0, ([Date].[Calendar].[Calendar Year]-[Date].[Calendar].[Calendar Year].&[2010]) ON 1  FROM [Adventure Works]";
            var cmd   = new AdomdCommand(query, new AdomdConnection(ConnectionStringReader.GetAdomd()));

            //Call the method to test
            var actual = ctr.Matches(cmd);

            //Assertion
            Assert.That(actual, Is.False);
        }
示例#4
0
        public void Matches_MdxQueryAndDecimalResulSetWithCorrectSettings_Matching()
        {
            //Buiding object used during test
            var objs = new List <object[]>()
            {
                new object[] { "CY 2005", 1874469.00 },
                new object[] { "CY 2006", 4511243.0 },
                new object[] { "CY 2007", 4709851 },
                new object[] { "CY 2008", 1513940 }
            };
            var resolver = new ObjectsResultSetResolver(new ObjectsResultSetResolverArgs(objs.ToArray()));
            var builder  = new ResultSetServiceBuilder();

            builder.Setup(resolver);
            var ctr = new EqualToConstraint(builder.GetService());

            ctr.Using(new SettingsOrdinalResultSet(
                          SettingsOrdinalResultSet.KeysChoice.First,
                          SettingsOrdinalResultSet.ValuesChoice.Last,
                          NumericAbsoluteTolerance.None)
                      );

            var mdx           = "SELECT [Measures].[Amount] ON 0, NON EMPTY([Date].[Calendar].[Calendar Year]) ON 1 FROM [Adventure Works]";
            var query         = new NBi.Core.Query.Query(mdx, ConnectionStringReader.GetAdomd());
            var actualBuilder = new ResultSetServiceBuilder();

            actualBuilder.Setup(new FakeQueryResultSetResolver(query, serviceLocator));
            var actual = actualBuilder.GetService();

            //Assertion
            Assert.That(ctr.Matches(actual));
        }
        public void Matches_MdxQueryAndSlighltyDifferentQueryWithCorrectSettingsAndTolerance_Matching()
        {
            //Buiding object used during test
            var expectedQuery = "WITH MEMBER [Measures].NewAmount AS [Measures].[Amount]+1";

            expectedQuery += " SELECT [Measures].NewAmount ON 0, ([Date].[Calendar].[Calendar Year].[CY 2005]:[Date].[Calendar].[Calendar Year].[CY 2008]) ON 1  FROM [Adventure Works]";
            var expectedCmd = new AdomdCommand(expectedQuery, new AdomdConnection(ConnectionStringReader.GetAdomd()));

            var ctr = new EqualToConstraint(expectedCmd);

            ctr.Using(new SettingsResultSetComparisonByIndex(
                          SettingsResultSetComparisonByIndex.KeysChoice.First,
                          SettingsResultSetComparisonByIndex.ValuesChoice.Last,
                          new List <IColumnDefinition>()
            {
                new Column()
                {
                    Index     = 1,
                    Role      = ColumnRole.Value,
                    Type      = ColumnType.Numeric,
                    Tolerance = "10"
                }
            }
                          )
                      );

            var query = "SELECT  [Measures].[Amount] ON 0, NON EMPTY([Date].[Calendar].[Calendar Year]) ON 1 FROM [Adventure Works]";
            var cmd   = new AdomdCommand(query, new AdomdConnection(ConnectionStringReader.GetAdomd()));

            //Call the method to test
            var actual = ctr.Matches(cmd);

            //Assertion
            Assert.That(actual, Is.True);
        }
        public void Matches_MdxQueryWithNullComparedToSqlWithValue_NonMatching()
        {
            //Buiding object used during test
            var expectedQuery = "SELECT 'CY 2010',  0 ";

            var expectedCmd = new SqlCommand(expectedQuery, new SqlConnection(ConnectionStringReader.GetSqlClient()));

            var ctr = new EqualToConstraint(expectedCmd);

            ctr.Using(
                new SettingsResultSetComparisonByIndex(
                    SettingsResultSetComparisonByIndex.KeysChoice.AllExpectLast,
                    SettingsResultSetComparisonByIndex.ValuesChoice.Last,
                    NumericAbsoluteTolerance.None
                    )
                );

            var query = "SELECT  [Measures].[Amount] ON 0, [Date].[Calendar].[Calendar Year].&[2010] ON 1 FROM [Adventure Works]";
            var cmd   = new AdomdCommand(query, new AdomdConnection(ConnectionStringReader.GetAdomd()));

            //Call the method to test
            var actual = ctr.Matches(cmd);

            //Assertion
            Assert.That(actual, Is.False);
        }
        public void Matches_SqlQueryWithDateComparedToStringAnotherHour_NonMatching()
        {
            //Buiding object used during test
            var expectedQuery = "SELECT 'CY 2010',  CAST('2010-01-01' AS DATE)";

            var expectedCmd = new SqlCommand(expectedQuery, new SqlConnection(ConnectionStringReader.GetSqlClient()));

            var columns = new List <IColumnDefinition>();

            columns.Add(new Column()
            {
                Index = 1, Role = ColumnRole.Value, Type = ColumnType.DateTime
            });

            var ctr = new EqualToConstraint(expectedCmd);

            ctr.Using(
                new SettingsResultSetComparisonByIndex(
                    SettingsResultSetComparisonByIndex.KeysChoice.AllExpectLast,
                    SettingsResultSetComparisonByIndex.ValuesChoice.Last,
                    columns
                    )
                );

            var query = "SELECT 'CY 2010',  '1/01/2010 01:00:00'";
            var cmd   = new SqlCommand(query, new SqlConnection(ConnectionStringReader.GetSqlClient()));

            //Call the method to test
            var actual = ctr.Matches(cmd);

            //Assertion
            Assert.That(actual, Is.False);
        }
示例#8
0
        public void Matches_MdxQueryWithNullComparedToSqlWithValue_NonMatching()
        {
            //Buiding object used during test
            var sql           = "SELECT 'CY 2010',  0 ";
            var expectedQuery = new NBi.Core.Query.Query(sql, ConnectionStringReader.GetSqlClient());
            var resolver      = new FakeQueryResultSetResolver(expectedQuery, serviceLocator);
            var builder       = new ResultSetServiceBuilder();

            builder.Setup(resolver);
            var ctr = new EqualToConstraint(builder.GetService());

            ctr.Using(
                new SettingsOrdinalResultSet(
                    SettingsOrdinalResultSet.KeysChoice.AllExpectLast,
                    SettingsOrdinalResultSet.ValuesChoice.Last,
                    NumericAbsoluteTolerance.None
                    )
                );

            var mdx   = "SELECT [Measures].[Amount] ON 0, [Date].[Calendar].[Calendar Year].&[2010] ON 1 FROM [Adventure Works]";
            var query = new NBi.Core.Query.Query(mdx, ConnectionStringReader.GetAdomd());

            var actualBuilder = new ResultSetServiceBuilder();

            actualBuilder.Setup(new FakeQueryResultSetResolver(query, serviceLocator));
            var actual = actualBuilder.GetService();

            //Assertion
            Assert.That(ctr.Matches(actual), Is.False);
        }
        public void Matches_MdxQueryAndResulSetWithCorrectSettings_Matching()
        {
            //Buiding object used during test
            var rs   = new ResultSet();
            var objs = new List <object[]>();

            objs.Add(new object[] { "CY 2005", "1874469.00" });
            objs.Add(new object[] { "CY 2006", "4511243.0" });
            objs.Add(new object[] { "CY 2007", "4709851" });
            objs.Add(new object[] { "CY 2008", "1513940" });
            rs.Load(objs);

            var ctr = new EqualToConstraint(rs);

            ctr.Using(new SettingsResultSetComparisonByIndex(
                          SettingsResultSetComparisonByIndex.KeysChoice.First,
                          SettingsResultSetComparisonByIndex.ValuesChoice.Last,
                          new NumericAbsoluteTolerance(500, SideTolerance.Both)
                          )
                      );

            var query = "SELECT [Measures].[Amount] ON 0, NON EMPTY([Date].[Calendar].[Calendar Year]) ON 1 FROM [Adventure Works]";
            var cmd   = new AdomdCommand(query, new AdomdConnection(ConnectionStringReader.GetAdomd()));

            //Call the method to test
            var actual = ctr.Matches(cmd);

            //Assertion
            Assert.That(actual, Is.True);
        }
示例#10
0
        public void Matches_MdxQueryAndSqlQueryWithCorrectSettings_Matching()
        {
            //Buiding object used during test
            var expectedQuery = "SELECT 'CY 2005',  1874469 UNION ";

            expectedQuery += " SELECT 'CY 2006', 4511243 UNION ";
            expectedQuery += " SELECT 'CY 2007', 4709851 UNION ";
            expectedQuery += " SELECT 'CY 2008', 1513940  ";

            var expectedCmd = new SqlCommand(expectedQuery, new SqlConnection(ConnectionStringReader.GetSqlClient()));
            var resolver    = new FakeQueryResultSetLoader(expectedCmd);
            var builder     = new ResultSetServiceBuilder();

            builder.Setup(resolver);
            var ctr = new EqualToConstraint(builder.GetService());

            ctr.Using(
                new SettingsIndexResultSet(
                    SettingsIndexResultSet.KeysChoice.AllExpectLast,
                    SettingsIndexResultSet.ValuesChoice.Last,
                    new List <IColumnDefinition>()
            {
                new Column()
                {
                    Index     = 1,
                    Role      = ColumnRole.Value,
                    Type      = ColumnType.Numeric,
                    Tolerance = "5"
                }
            }
                    )
                );

            var query = "SELECT  [Measures].[Amount] ON 0, NON EMPTY([Date].[Calendar].[Calendar Year]) ON 1 FROM [Adventure Works]";
            var cmd   = new AdomdCommand(query, new AdomdConnection(ConnectionStringReader.GetAdomd()));


            var actualBuilder = new ResultSetServiceBuilder();

            actualBuilder.Setup(new FakeQueryResultSetLoader(cmd));
            var actual = actualBuilder.GetService();

            //Assertion
            Assert.That(ctr.Matches(actual));
        }
示例#11
0
        public void Matches_MdxQueryAndSlighltyDifferentQueryWithCorrectSettingsAndTolerance_Matching()
        {
            //Buiding object used during test
            var mdx = "WITH MEMBER [Measures].NewAmount AS [Measures].[Amount]+1";

            mdx += " SELECT [Measures].NewAmount ON 0, ([Date].[Calendar].[Calendar Year].[CY 2005]:[Date].[Calendar].[Calendar Year].[CY 2008]) ON 1  FROM [Adventure Works]";
            var expectedQuery = new NBi.Core.Query.Query(mdx, ConnectionStringReader.GetAdomd());
            var resolver      = new FakeQueryResultSetResolver(expectedQuery, serviceLocator);
            var builder       = new ResultSetServiceBuilder();

            builder.Setup(resolver);
            var ctr = new EqualToConstraint(builder.GetService());

            ctr.Using(new SettingsOrdinalResultSet(
                          SettingsOrdinalResultSet.KeysChoice.First,
                          SettingsOrdinalResultSet.ValuesChoice.Last,
                          new List <IColumnDefinition>()
            {
                new Column()
                {
                    Identifier = new ColumnOrdinalIdentifier(1),
                    Role       = ColumnRole.Value,
                    Type       = ColumnType.Numeric,
                    Tolerance  = "10"
                }
            }
                          )
                      );

            var query = "SELECT  [Measures].[Amount] ON 0, NON EMPTY([Date].[Calendar].[Calendar Year]) ON 1 FROM [Adventure Works]";
            var cmd   = new NBi.Core.Query.Query(query, ConnectionStringReader.GetAdomd());


            var actualBuilder = new ResultSetServiceBuilder();

            actualBuilder.Setup(new FakeQueryResultSetResolver(cmd, serviceLocator));
            var actual = actualBuilder.GetService();

            //Assertion
            Assert.That(ctr.Matches(actual));
        }
示例#12
0
        public void Matches_SqlQueryWithDateComparedToStringAnotherHour_NonMatching()
        {
            //Buiding object used during test
            var expectedQuery = "SELECT 'CY 2010',  CAST('2010-01-01' AS DATE)";

            var expectedCmd = new SqlCommand(expectedQuery, new SqlConnection(ConnectionStringReader.GetSqlClient()));

            var columns = new List <IColumnDefinition>()
            {
                new Column()
                {
                    Index = 1, Role = ColumnRole.Value, Type = ColumnType.DateTime
                }
            };

            var expectedLoader  = new FakeQueryResultSetLoader(expectedCmd);
            var expectedBuilder = new ResultSetServiceBuilder();

            expectedBuilder.Setup(expectedLoader);
            var ctr = new EqualToConstraint(expectedBuilder.GetService());

            ctr.Using(
                new SettingsIndexResultSet(
                    SettingsIndexResultSet.KeysChoice.AllExpectLast,
                    SettingsIndexResultSet.ValuesChoice.Last,
                    columns
                    )
                );

            var query   = "SELECT 'CY 2010',  '1/01/2010 01:00:00'";
            var cmd     = new SqlCommand(query, new SqlConnection(ConnectionStringReader.GetSqlClient()));
            var builder = new ResultSetServiceBuilder();

            builder.Setup(new FakeQueryResultSetLoader(cmd));
            var actual = builder.GetService();

            //Assertion
            Assert.That(ctr.Matches(actual), Is.False);
        }
示例#13
0
        public void Matches_MdxQueryAndSqlQueryWithCorrectSettings_Matching()
        {
            //Buiding object used during test
            var expectedQuery = "SELECT 'CY 2005',  1874469 UNION ";

            expectedQuery += " SELECT 'CY 2006', 4511243 UNION ";
            expectedQuery += " SELECT 'CY 2007', 4709851 UNION ";
            expectedQuery += " SELECT 'CY 2008', 1513940  ";

            var expectedCmd = new SqlCommand(expectedQuery, new SqlConnection(ConnectionStringReader.GetSqlClient()));

            var ctr = new EqualToConstraint(expectedCmd);

            ctr.Using(
                new SettingsResultSetComparisonByIndex(
                    SettingsResultSetComparisonByIndex.KeysChoice.AllExpectLast,
                    SettingsResultSetComparisonByIndex.ValuesChoice.Last,
                    new List <IColumnDefinition>()
            {
                new Column()
                {
                    Index     = 1,
                    Role      = ColumnRole.Value,
                    Type      = ColumnType.Numeric,
                    Tolerance = "5"
                }
            }
                    )
                );

            var query = "SELECT  [Measures].[Amount] ON 0, NON EMPTY([Date].[Calendar].[Calendar Year]) ON 1 FROM [Adventure Works]";
            var cmd   = new AdomdCommand(query, new AdomdConnection(ConnectionStringReader.GetAdomd()));

            //Call the method to test
            var actual = ctr.Matches(cmd);

            //Assertion
            Assert.That(actual, Is.True);
        }
示例#14
0
        public void Matches_SqlQueryWithDateComparedToStringAnotherHour_NonMatching()
        {
            //Buiding object used during test
            var expectedSql   = "SELECT 'CY 2010',  CAST('2010-01-01' AS DATE)";
            var expectedQuery = new NBi.Core.Query.Query(expectedSql, ConnectionStringReader.GetSqlClient());

            var columns = new List <IColumnDefinition>()
            {
                new Column()
                {
                    Identifier = new ColumnOrdinalIdentifier(1), Role = ColumnRole.Value, Type = ColumnType.DateTime
                }
            };

            var expectedLoader  = new FakeQueryResultSetResolver(expectedQuery, serviceLocator);
            var expectedBuilder = new ResultSetServiceBuilder();

            expectedBuilder.Setup(expectedLoader);
            var ctr = new EqualToConstraint(expectedBuilder.GetService());

            ctr.Using(
                new SettingsOrdinalResultSet(
                    SettingsOrdinalResultSet.KeysChoice.AllExpectLast,
                    SettingsOrdinalResultSet.ValuesChoice.Last,
                    columns
                    )
                );

            var sql2    = "SELECT 'CY 2010',  '1/01/2010 01:00:00'";
            var query   = new NBi.Core.Query.Query(sql2, ConnectionStringReader.GetSqlClient());
            var builder = new ResultSetServiceBuilder();

            builder.Setup(new FakeQueryResultSetResolver(query, serviceLocator));
            var actual = builder.GetService();

            //Assertion
            Assert.That(ctr.Matches(actual), Is.False);
        }
示例#15
0
        public void Matches_MdxQueryAndSameQueryWithCorrectSettings_Matching()
        {
            //Buiding object used during test
            var expectedQuery = "SELECT [Measures].[Amount] ON 0, NON EMPTY([Date].[Calendar].[Calendar Year]) ON 1 FROM [Adventure Works]";
            var expectedCmd   = new AdomdCommand(expectedQuery, new AdomdConnection(ConnectionStringReader.GetAdomd()));

            var ctr = new EqualToConstraint(expectedCmd);

            ctr.Using(new ResultSetComparisonSettings(
                          ResultSetComparisonSettings.KeysChoice.First,
                          ResultSetComparisonSettings.ValuesChoice.Last,
                          NumericAbsoluteTolerance.None)
                      );

            var query = "SELECT [Measures].[Amount] ON 0, NON EMPTY([Date].[Calendar].[Calendar Year]) ON 1  FROM [Adventure Works]";
            var cmd   = new AdomdCommand(query, new AdomdConnection(ConnectionStringReader.GetAdomd()));

            //Call the method to test
            var actual = ctr.Matches(cmd);

            //Assertion
            Assert.That(actual, Is.True);
        }
示例#16
0
        public void Matches_SqlQueryWithDateComparedToString_Matching()
        {
            var expectedSql   = "SELECT 'CY 2010',  CAST('2010-01-01' AS DATE)";
            var expectedQuery = new NBi.Core.Query.Query(expectedSql, ConnectionStringReader.GetSqlClient());

            var columns = new List <IColumnDefinition>()
            {
                new Column()
                {
                    Index = 1, Role = ColumnRole.Value, Type = ColumnType.DateTime
                }
            };
            var resolver = new FakeQueryResultSetResolver(expectedQuery, serviceLocator);
            var builder  = new ResultSetServiceBuilder();

            builder.Setup(resolver);
            var ctr = new EqualToConstraint(builder.GetService());

            ctr.Using(
                new SettingsIndexResultSet(
                    SettingsIndexResultSet.KeysChoice.AllExpectLast,
                    SettingsIndexResultSet.ValuesChoice.Last,
                    columns
                    )
                );

            var sql   = "SELECT 'CY 2010',  '1/01/2010 00:00:00'";
            var query = new NBi.Core.Query.Query(sql, ConnectionStringReader.GetSqlClient());

            var actualBuilder = new ResultSetServiceBuilder();

            actualBuilder.Setup(new FakeQueryResultSetResolver(query, serviceLocator));
            var actual = actualBuilder.GetService();

            //Assertion
            Assert.That(ctr.Matches(actual));
        }
示例#17
0
        public void Matches_MdxQueryAndResulSetWithCorrectSettings_Matching()
        {
            //Buiding object used during test
            var objs = new List <object[]>()
            {
                new object[] { "CY 2005", "1874469.00" },
                new object[] { "CY 2006", "4511243.0" },
                new object[] { "CY 2007", "4709851" },
                new object[] { "CY 2008", "1513940" }
            };

            var resolver = new ObjectsResultSetResolver(new ObjectsResultSetResolverArgs(objs.ToArray()));
            var builder  = new ResultSetServiceBuilder();

            builder.Setup(resolver);
            var ctr = new EqualToConstraint(builder.GetService());

            ctr.Using(new SettingsIndexResultSet(
                          SettingsIndexResultSet.KeysChoice.First,
                          SettingsIndexResultSet.ValuesChoice.Last,
                          new NumericAbsoluteTolerance(500, SideTolerance.Both)
                          )
                      );

            var query = "SELECT [Measures].[Amount] ON 0, NON EMPTY([Date].[Calendar].[Calendar Year]) ON 1 FROM [Adventure Works]";
            var cmd   = new AdomdCommand(query, new AdomdConnection(ConnectionStringReader.GetAdomd()));


            var actualBuilder = new ResultSetServiceBuilder();

            actualBuilder.Setup(new FakeQueryResultSetLoader(cmd));
            var actual = actualBuilder.GetService();

            //Assertion
            Assert.That(ctr.Matches(actual));
        }