public void ContainConstraint_FindNonExistingHierarchyBellowSpecificDimension_Failure()
{
var provider = new StructureDiscoveryFactoryProvider();
var factory = provider.Instantiate(ConnectionStringReader.GetAdomd());
var discovery = factory.Instantiate(
Target.Hierarchies
, TargetType.Object
, new CaptionFilter[] {
new CaptionFilter(Target.Perspectives, "Adventure Works")
, new CaptionFilter(Target.Dimensions, "Product")
});
var ctr = new ContainConstraint("Not existing");
//Method under test
Assert.That(ctr.Matches(discovery), Is.False);
}
public void Matches_ActualMoreThanExpectation_Failure()
{
var discovery = new DiscoveryRequestFactory().BuildDirect(
ConnectionStringReader.GetAdomd()
, DiscoveryTarget.Perspectives
, new List <IFilter>());
var expectedStrings = new string[] { "Adventure Works", "Channel Sales", "Direct Sales", "Finance", "Mined Customers", "Sales Summary", "Sales Targets" };
var expected = new List <string>();
expected.AddRange(expectedStrings);
expected.RemoveAt(0);
var ctr = new SubsetOfConstraint(expected);
//Method under test
Assert.That(ctr.Matches(discovery), Is.False);
}
public void Execute_ValidDax_GetResult()
{
var query = "EVALUATE CALCULATETABLE(VALUES('Product Subcategory'[Product Subcategory Name]),'Product Category'[Product Category Name] = \"Bikes\")";
var cmd = new AdomdCommand(query, new AdomdConnection(ConnectionStringReader.GetAdomdTabular()));
var qe = new QueryAdomdEngine(cmd);
var ds = qe.Execute();
Assert.IsInstanceOf <string>(ds.Tables[0].Rows[0][0]);
Assert.AreEqual((string)ds.Tables[0].Rows[0][0], "Mountain Bikes");
Assert.AreEqual((string)ds.Tables[0].Rows[1][0], "Road Bikes");
Assert.AreEqual((string)ds.Tables[0].Rows[2][0], "Touring Bikes");
Assert.AreEqual(ds.Tables[0].Rows.Count, 3);
Assert.AreEqual(ds.Tables[0].Columns.Count, 1);
}
public void Matches_ActualEqualToExpectationButCaseNonMatching_Success()
{
var provider = new StructureDiscoveryFactoryProvider();
var factory = provider.Instantiate(ConnectionStringReader.GetAdomd());
var discovery = factory.Instantiate(
Target.Perspectives
, TargetType.Object
, new CaptionFilter[] { });
var expected = new string[] { "Adventure Works".ToLower(), "Channel Sales".ToUpper(), "Direct Sales", "Finance", "Sales Summary", "Sales Targets" };
var ctr = new EquivalentToConstraint(expected);
ctr = ctr.IgnoreCase;
//Method under test
Assert.That(discovery, ctr);
}
public void ContainConstraint_FindNonExistingMeasure_Failure()
{
var provider = new StructureDiscoveryFactoryProvider();
var factory = provider.Instantiate(ConnectionStringReader.GetAdomd());
var discovery = factory.Instantiate(
Target.Measures
, TargetType.Object
, new CaptionFilter[] {
new CaptionFilter(Target.Perspectives, "Adventure Works")
, new CaptionFilter(Target.MeasureGroups, "Reseller Orders")
});
var ctr = new ContainConstraint("Not existing");
//Method under test
Assert.That(ctr.Matches(discovery), Is.False);
}
public void ContainConstraint_FindExistingMeasure_Success()
{
var provider = new StructureDiscoveryFactoryProvider();
var factory = provider.Instantiate(ConnectionStringReader.GetAdomd());
var discovery = factory.Instantiate(
Target.Measures
, TargetType.Object
, new CaptionFilter[] {
new CaptionFilter(Target.Perspectives, "Adventure Works")
, new CaptionFilter(Target.MeasureGroups, "Reseller Orders")
});
var ctr = new ContainConstraint("Reseller Order Count");
//Method under test
Assert.That(discovery, ctr);
}
public void ContainConstraint_FindExistingHierarchyBellowSpecificDimension_Success()
{
var provider = new StructureDiscoveryFactoryProvider();
var factory = provider.Instantiate(ConnectionStringReader.GetAdomd());
var discovery = factory.Instantiate(
Target.Hierarchies
, TargetType.Object
, new CaptionFilter[] {
new CaptionFilter(Target.Perspectives, "Adventure Works")
, new CaptionFilter(Target.Dimensions, "Product")
});
var ctr = new ContainConstraint("Product Model Lines");
//Method under test
Assert.That(discovery, ctr);
}
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));
}
public void Execute_ProjectionOfObjects_DataSetFilled()
{
var client = new GremlinLikeClientFactory().Instantiate(ConnectionStringReader.GetGremlin());
var statement = Mock.Of <IQuery>(x => x.Statement == "g.V().project('FirstName','KnowsCount').by('firstName').by(out().count())");
var gremlinQuery = new GremlinCommandFactory().Instantiate(client, statement).Implementation as GremlinCommandOperation;
var engine = new GremlinExecutionEngine((GremlinClientOperation)(client.CreateNew()), gremlinQuery);
var ds = engine.Execute();
Assert.That(ds.Tables, Has.Count.EqualTo(1));
Assert.That(ds.Tables[0].Rows, Has.Count.EqualTo(4));
Assert.That(ds.Tables[0].Columns, Has.Count.EqualTo(2));
Assert.That(ds.Tables[0].Columns.Cast <DataColumn>().Select(x => x.ColumnName), Has.Member("FirstName"));
Assert.That(ds.Tables[0].Columns.Cast <DataColumn>().Select(x => x.ColumnName), Has.Member("KnowsCount"));
var firstNames = new List <object>();
var knowsCount = new List <object>();
foreach (DataRow row in ds.Tables[0].Rows)
{
for (int i = 0; i < ds.Tables[0].Columns.Count; i++)
{
if (row.Table.Columns[i].ColumnName == "FirstName")
{
firstNames.Add(row.ItemArray[i]);
}
else if (row.Table.Columns[i].ColumnName == "KnowsCount")
{
knowsCount.Add(row.ItemArray[i]);
}
}
}
foreach (var expectedFirstName in new[] { "Thomas", "Mary", "Ben", "Robin" })
{
Assert.That(firstNames, Has.Member(expectedFirstName));
}
foreach (var expectedKnowsCount in new object[] { 2, 1, 0 })
{
Assert.That(knowsCount, Has.Member(expectedKnowsCount));
}
}
public void LinkedToConstraint_ExistingPerspectiveDimensionAndMeasureGroupLinkedWithoutCaseMatching_Success()
{
var discovery = new DiscoveryRequestFactory().BuildRelation(
ConnectionStringReader.GetAdomd()
, DiscoveryTarget.MeasureGroups
, new List <IFilter>()
{
new CaptionFilter("Adventure Works", DiscoveryTarget.Perspectives)
, new CaptionFilter("Customer", DiscoveryTarget.Dimensions)
});
var ctr = new LinkedToConstraint("Internet Sales".ToLower());
ctr = ctr.IgnoreCase;
//Method under test
Assert.That(discovery, ctr);
}
public void GetMembers_ByLevel_ReturnListMembersWithCorrectLevelNumber()
{
var mae = new MembersAdomdEngine();
var disco = new DiscoveryRequestFactory().Build(
ConnectionStringReader.GetAdomd(),
string.Empty,
"Adventure Works",
"Geography",
"Geography",
"Country"
);
//Call the method to test
var actual = mae.GetMembers(disco);
//Assertion
Assert.That(List.Map(actual).Property("LevelNumber"), Has.All.EqualTo(1));
}
public void Execute_TabularDateDimensionLinkedToThreeMeasureGroups_ListStructureContainingThreeElements()
{
var disco = new DiscoveryRequestFactory().BuildRelation(
ConnectionStringReader.GetAdomd()
, DiscoveryTarget.MeasureGroups
, new List <IFilter>()
{
new CaptionFilter("Internet Operation", DiscoveryTarget.Perspectives)
, new CaptionFilter("Date", DiscoveryTarget.Dimensions)
});
var factory = new AdomdDiscoveryCommandFactory();
var cmd = factory.BuildExact(disco);
var structs = cmd.Execute();
Assert.That(structs.Count(), Is.EqualTo(3));
}
public void List_LevelWithMemberChildren_ListOfMembers()
{
var connStr = ConnectionStringReader.GetAdomd();
var member = "January 2005";
var cmd = new MembersCommand(connStr, "Children", member, null, null);
var filters = new List <CaptionFilter>()
{
new CaptionFilter("Adventure Works", DiscoveryTarget.Perspectives),
new CaptionFilter("Date", DiscoveryTarget.Dimensions),
new CaptionFilter("Calendar", DiscoveryTarget.Hierarchies),
new CaptionFilter("Month", DiscoveryTarget.Levels)
};
var result = cmd.List(filters);
//Returns the 31 days of the month
Assert.That(result.Count, Is.EqualTo(31));
}
public void ExistsConstraint_ExistingPerspectiveButWrongCaseWithIgnoreCaseTrue_Success()
{
var discovery = new DiscoveryRequestFactory().BuildDirect(
ConnectionStringReader.GetAdomd()
, DiscoveryTarget.Perspectives
, new List <IFilter>()
{
new CaptionFilter("Adventure Works", DiscoveryTarget.Perspectives),
new CaptionFilter("Date", DiscoveryTarget.Dimensions)
});
var ctr = new ExistsConstraint();
ctr = ctr.IgnoreCase;
//Method under test
Assert.That(discovery, ctr);
}
private ExternalFileQueryResolverArgs BuildArgs()
{
return(new ExternalFileQueryResolverArgs(
@"Integration\Core\Resources\query.sql",
ConnectionStringReader.GetSqlClient(),
new List <IQueryParameter>()
{
new QueryParameter("param", "10")
},
new List <IQueryTemplateVariable>()
{
new QueryTemplateVariableXml()
{
Name = "operator", Value = "not in"
}
},
new TimeSpan(0, 0, 10)));
}
public void ExtractQuery_ExistingReportAndDataSet_CorrectQueryReturned()
{
var request = new ReportDataSetRequest(
ConnectionStringReader.GetReportServerDatabase()
, "/AdventureWorks Sample Reports/"
, "Currency_List"
, "Currency"
);
var parser = new DatabaseReportingParser();
var query = parser.ExtractCommand(request);
Assert.That(query.Text,
Does.Contain("SELECT").And
.StringContaining("[CurrencyAlternateKey]").And
.StringContaining("[DimCurrency]"));
Assert.That(query.CommandType, Is.EqualTo(CommandType.Text));
}
public void ContainConstraint_FindExistingMeasureWithCaseNonMatching_Success()
{
var discovery = new DiscoveryRequestFactory().BuildDirect(
ConnectionStringReader.GetAdomd()
, DiscoveryTarget.Measures
, new List <IFilter>()
{
new CaptionFilter("Adventure Works", DiscoveryTarget.Perspectives)
, new CaptionFilter("Reseller Orders", DiscoveryTarget.MeasureGroups)
});
var ctr = new ContainConstraint("Reseller Order Count".ToLower());
ctr = ctr.IgnoreCase;
//Method under test
Assert.That(discovery, ctr);
}
private ReportDataSetQueryResolverArgs BuildArgs()
{
return(new ReportDataSetQueryResolverArgs(
@"C:\", @"Path\", "MyReport", "MyDataSet",
ConnectionStringReader.GetSqlClient(),
new List <IQueryParameter>()
{
new QueryParameter("param", "10")
},
new List <IQueryTemplateVariable>()
{
new QueryTemplateVariableXml()
{
Name = "operator", Value = "not in"
}
},
new TimeSpan(0, 0, 10)));
}
public void Execute_TabularDateDimensionWithHeighTeenHierarchies_ListStructureContainingSevenTeenElements()
{
var disco = new DiscoveryRequestFactory().BuildDirect(
ConnectionStringReader.GetAdomdTabular(),
DiscoveryTarget.Hierarchies,
new List <IFilter>()
{
new CaptionFilter("Internet Operation", DiscoveryTarget.Perspectives),
new CaptionFilter("Date", DiscoveryTarget.Dimensions)
});
var factory = new AdomdDiscoveryCommandFactory();
var cmd = factory.BuildExact(disco);
var structs = cmd.Execute();
Assert.That(structs.Count(), Is.EqualTo(17));
}
public void GetSystemUnderTest_Build_CorrectSystemUnderTest()
{
var sutXml = new StructureXml();
var item = new PerspectiveXml();
sutXml.Item = item;
item.ConnectionString = ConnectionStringReader.GetAdomd();
item.Caption = "perspective";
var ctrXml = new ExistsXml();
var builder = new StructureExistsBuilder();
builder.Setup(sutXml, ctrXml);
builder.Build();
var sut = builder.GetSystemUnderTest();
Assert.That(sut, Is.InstanceOf <StructureDiscoveryCommand>());
}
public void Execute_DateDimensionLinkedToElevenMeasureGroups_ListStructureContainingTenElements()
{
var disco = new DiscoveryRequestFactory().BuildRelation(
ConnectionStringReader.GetAdomd()
, DiscoveryTarget.MeasureGroups
, new List <IFilter>()
{
new CaptionFilter("Adventure Works", DiscoveryTarget.Perspectives)
, new CaptionFilter("Customer", DiscoveryTarget.Dimensions)
});
var factory = new AdomdDiscoveryCommandFactory();
var cmd = factory.BuildExact(disco);
var structs = cmd.Execute();
Assert.That(structs.Count(), Is.EqualTo(10));
}
public void ContainConstraint_FindExistingLevel_Success()
{
var provider = new StructureDiscoveryFactoryProvider();
var factory = provider.Instantiate(ConnectionStringReader.GetAdomd());
var discovery = factory.Instantiate(
Target.Levels
, TargetType.Object
, new CaptionFilter[] {
new CaptionFilter(Target.Perspectives, "Adventure Works")
, new CaptionFilter(Target.Dimensions, "Customer")
, new CaptionFilter(Target.Hierarchies, "Customer Geography")
});
var ctr = new ContainConstraint("City");
//Method under test
Assert.That(discovery, ctr);
}
private EmbeddedQueryResolverArgs BuildArgs()
{
return(new EmbeddedQueryResolverArgs(
"select * from myTable;",
ConnectionStringReader.GetSqlClient(),
new List <IQueryParameter>()
{
new QueryParameter("param", "10")
},
new List <IQueryTemplateVariable>()
{
new QueryTemplateVariableXml()
{
Name = "operator", Value = "not in"
}
},
new TimeSpan(0, 0, 10)));
}
public void GetSystemUnderTest_CorrectPerspectiveTarget_Success()
{
//Buiding object used during test
var ctrXmlStubFactory = new Mock <EquivalentToXml>();
var ctrXml = ctrXmlStubFactory.Object;
var sutXml = new StructureXml();
sutXml.Item = new PerspectivesXml();
sutXml.Item.ConnectionString = ConnectionStringReader.GetAdomd();
var builder = new StructureEquivalentToBuilder();
builder.Setup(sutXml, ctrXml);
builder.Build();
var sut = builder.GetSystemUnderTest();
//Assertion
Assert.That(sut, Is.InstanceOf <OlapCommand>());
}
public void Init()
{
const string connectionStringPath = @"\\psf\Home\Dropbox\Dox\Mac-Git\connectionString.txt";
connectionString_ = ConnectionStringReader.GetConnectionString(connectionStringPath);
var dbFactory = new OrmLiteConnectionFactory(connectionString_, OrmLiteDialectProvider);
using (var db = dbFactory.OpenDbConnection())
{
db.ExecuteSql(CustomProvider.CreateSmallTestClass);
db.ExecuteSql(CustomProvider.CreateBigTestClass);
db.ExecuteSql(CustomProvider.CreateTestClassWithFk);
db.ExecuteSql(CustomProvider.CreateTestClassWithOutFk);
db.ExecuteSql(CustomProvider.CreateTestClassWithNotNullInt);
db.ExecuteSql(CustomProvider.CreateTestClassFromIntToDouble);
db.ExecuteSql(CustomProvider.CreateTestClassWithNullDouble);
db.ExecuteSql(CustomProvider.CreateTestClassWithoutAutoIncrementId);
}
}
public void List_HierarchyWithExclusionOfAll_ListOfMembers()
{
var connStr = ConnectionStringReader.GetAdomd();
var excludedMembers = new List <string>()
{
"All"
};
var cmd = new MembersCommand(connStr, "Members", null, excludedMembers, null);
var filters = new List <CaptionFilter>()
{
new CaptionFilter("Adventure Works", DiscoveryTarget.Perspectives),
new CaptionFilter("Date", DiscoveryTarget.Dimensions),
new CaptionFilter("Month Of Year", DiscoveryTarget.Hierarchies),
};
var result = cmd.List(filters);
Assert.That(result.Count, Is.EqualTo(12));
}
public void GetPartialMetadata_TabularCalendarHierarchyWithSixLevels_ListStructureContainingSixElements()
{
var disco = new DiscoveryRequestFactory().BuildDirect(
ConnectionStringReader.GetAdomdTabular(),
DiscoveryTarget.Levels,
new List <IFilter>()
{
new CaptionFilter("Internet Operation", DiscoveryTarget.Perspectives),
new CaptionFilter("Date", DiscoveryTarget.Dimensions),
new CaptionFilter("Calendar", DiscoveryTarget.Hierarchies)
});
var factory = new AdomdDiscoveryCommandFactory();
var cmd = factory.BuildExact(disco);
var structs = cmd.Execute();
Assert.That(structs.Count(), Is.EqualTo(6));
}
public void LinkedToConstraint_ExistingPerspectiveDimensionAndMeasureGroupLinkedWithoutCaseMatching_Success()
{
var provider = new StructureDiscoveryFactoryProvider();
var factory = provider.Instantiate(ConnectionStringReader.GetAdomd());
var discovery = factory.Instantiate(
Target.MeasureGroups
, TargetType.Relation
, new CaptionFilter[] {
new CaptionFilter(Target.Perspectives, "Adventure Works")
, new CaptionFilter(Target.Dimensions, "Customer")
});
var ctr = new LinkedToConstraint("Internet Sales".ToLower());
ctr = ctr.IgnoreCase;
//Method under test
Assert.That(discovery, ctr);
}
public void Matches_ActualMoreThanExpectation_Failure()
{
var provider = new StructureDiscoveryFactoryProvider();
var factory = provider.Instantiate(ConnectionStringReader.GetAdomd());
var discovery = factory.Instantiate(
Target.Perspectives
, TargetType.Object
, new CaptionFilter[] { });
var expectedStrings = new string[] { "Adventure Works", "Channel Sales", "Direct Sales", "Finance", "Mined Customers", "Sales Summary", "Sales Targets" };
var expected = new List <string>();
expected.AddRange(expectedStrings);
expected.RemoveAt(0);
var ctr = new EquivalentToConstraint(expected);
//Method under test
Assert.That(ctr.Matches(discovery), Is.False);
}
public void Execute_InvalidAbsolutePath_MessageAbsolutePath()
{
var args = new AssemblyQueryResolverArgs(
@"C:\NotExisting.dll",
"NBi.Testing.Acceptance.Resources.AssemblyClass",
"GetTextSelectSql",
false,
new Dictionary <string, object>()
{
{ "prefix", "CY" }
},
ConnectionStringReader.GetSqlClient(),
null, null, 10);
var resolver = new AssemblyQueryResolver(args);
var ex = Assert.Catch <ExternalDependencyNotFoundException>(() => resolver.Execute());
Assert.That(ex.Message, Is.StringContaining(@"C:\NotExisting.dll"));
}
