public void WriteTo_FailingAssertionForDimension_TextContainsCaptionOfExpectedDimensionAndNameOfPerspective()
{
var description = new CommandDescription(Target.Dimensions,
new CaptionFilter[]
{
new CaptionFilter(Target.Perspectives, "perspective-name")
});
var actuals = new string[] { "Actual dimension 1", "Actual dimension 2", "Actual dimension 3" };
var commandStub = new Mock <IStructureDiscoveryCommand>();
commandStub.Setup(cmd => cmd.Execute()).Returns(actuals);
commandStub.Setup(cmd => cmd.Description).Returns(description);
var existsConstraint = new ExistsConstraint("expected-dimension-caption");
//Method under test
string assertionText = null;
try
{
Assert.That(commandStub.Object, existsConstraint);
}
catch (AssertionException ex)
{
assertionText = ex.Message;
}
//Test conclusion
Console.WriteLine(assertionText);
Assert.That(assertionText, Is.StringContaining("perspective-name").And
.StringContaining("expected-dimension-caption"));
}
public void WriteTo_FailingAssertionForDimensionWithMinorMistake_TextContainsTheSuggestionOfValue()
{
var description = new CommandDescription(Target.MeasureGroups,
new CaptionFilter[]
{
new CaptionFilter(Target.Perspectives, "perspective-name")
});
var actuals = new string[] { "expected-dimension-catpion" };
var commandStub = new Mock <IStructureDiscoveryCommand>();
commandStub.Setup(cmd => cmd.Execute()).Returns(actuals);
commandStub.Setup(cmd => cmd.Description).Returns(description);
var existsConstraint = new ExistsConstraint("expected-dimension-caption");
//Method under test
string assertionText = null;
try
{
Assert.That(commandStub.Object, existsConstraint);
}
catch (AssertionException ex)
{
assertionText = ex.Message;
}
//Test conclusion
Console.WriteLine(assertionText);
Assert.That(assertionText, Is.StringContaining("The value 'expected-dimension-catpion' is close to your expectation."));
}
public void WriteTo_FailingAssertionForPerspectiveWithInvestigationReturningNoField_TextContainsFewKeyInfo()
{
var description = new CommandDescription(Target.MeasureGroups,
new CaptionFilter[]
{
new CaptionFilter(Target.Perspectives, "perspective-name")
});
var actuals = new string[] {};
var commandStub = new Mock <IStructureDiscoveryCommand>();
commandStub.Setup(cmd => cmd.Execute()).Returns(actuals);
commandStub.Setup(cmd => cmd.Description).Returns(description);
var existsConstraint = new ExistsConstraint("expected-measure-group-caption");
//Method under test
string assertionText = null;
try
{
Assert.That(commandStub.Object, existsConstraint);
}
catch (AssertionException ex)
{
assertionText = ex.Message;
}
//Test conclusion
Console.WriteLine(assertionText);
Assert.That(assertionText, Is.StringContaining("nothing found"));
}
public void WriteTo_FailingAssertionForPerspectiveWithNot_TextContainsFewKeyInfo()
{
var request = new DiscoveryRequestFactory().BuildDirect(
"connectionString",
DiscoveryTarget.Perspectives,
new List <IFilter>()
{
new CaptionFilter("expected-perspective-name", DiscoveryTarget.Perspectives)
});
var elements = new List <IField>();
elements.Add(new Perspective("expected-perspective-name"));
var commandExactStub = new Mock <AdomdDiscoveryCommand>("connectionString");
commandExactStub.Setup(f => f.Execute())
.Returns(elements);
var commandExternalStub = new Mock <AdomdDiscoveryCommand>("connectionString");
commandExternalStub.Setup(f => f.Execute())
.Returns(elements);
var factoryStub = new Mock <AdomdDiscoveryCommandFactory>();
factoryStub.Setup(f => f.BuildExact(request))
.Returns(commandExactStub.Object);
elements.Add(new Perspective("unexpected-perspective-name"));
factoryStub.Setup(f => f.BuildExternal(It.IsAny <MetadataDiscoveryRequest>()))
.Returns(commandExternalStub.Object);
var factory = factoryStub.Object;
var existsConstraint = new ExistsConstraint()
{
CommandFactory = factory
};
var notExistsConstraint = new NotConstraint(existsConstraint);
//Method under test
string assertionText = null;
try
{
Assert.That(request, notExistsConstraint);
}
catch (AssertionException ex)
{
assertionText = ex.Message;
}
//Test conclusion
Console.WriteLine(assertionText);
Assert.That(assertionText, Is.StringContaining("not find"));
}
public void WriteTo_FailingAssertionForDimensionWithMinorMistake_TextContainsTheSuggestionOfValue()
{
var request = new DiscoveryRequestFactory().BuildDirect(
"connectionString",
DiscoveryTarget.Dimensions,
new List <IFilter>()
{
new CaptionFilter("perspective-name", DiscoveryTarget.Perspectives)
, new CaptionFilter("expected-dimension-caption", DiscoveryTarget.Dimensions)
});
var commandExactStub = new Mock <AdomdDiscoveryCommand>("connectionString");
commandExactStub.Setup(f => f.Execute())
.Returns(new List <Dimension>());
var commandExternalStub = new Mock <AdomdDiscoveryCommand>("connectionString");
commandExternalStub.Setup(f => f.Execute())
.Returns(new List <Dimension>()
{
new Dimension("Dimension", "expected-dimension-catpion"), //two letters permutted
new Dimension("Toto", "Toto")
});
var factoryStub = new Mock <AdomdDiscoveryCommandFactory>();
factoryStub.Setup(f => f.BuildExact(request))
.Returns(commandExactStub.Object);
factoryStub.Setup(f => f.BuildExternal(It.IsAny <MetadataDiscoveryRequest>()))
.Returns(commandExternalStub.Object);
var factory = factoryStub.Object;
var existsConstraint = new ExistsConstraint()
{
CommandFactory = factory
};
//Method under test
string assertionText = null;
try
{
Assert.That(request, existsConstraint);
}
catch (AssertionException ex)
{
assertionText = ex.Message;
}
//Test conclusion
Console.WriteLine(assertionText);
Assert.That(assertionText, Is.StringContaining("The value 'expected-dimension-catpion' is close to your expectation."));
}
public void WriteTo_FailingAssertionForHierarchy_TextContainsCaptionOfExpectedHierarchyAndCaptionOfFilters()
{
var request = new DiscoveryRequestFactory().BuildDirect(
"connectionString",
DiscoveryTarget.Hierarchies,
new List <IFilter>()
{
new CaptionFilter("perspective-name", DiscoveryTarget.Perspectives)
, new CaptionFilter("dimension-caption", DiscoveryTarget.Dimensions)
, new CaptionFilter("expected-hierarchy-caption", DiscoveryTarget.Hierarchies)
});
var elements = new List <IField>();
var commandExactStub = new Mock <AdomdDiscoveryCommand>("connectionString");
commandExactStub.Setup(f => f.Execute())
.Returns(elements);
var commandExternalStub = new Mock <AdomdDiscoveryCommand>("connectionString");
commandExternalStub.Setup(f => f.Execute())
.Returns(elements);
var factoryStub = new Mock <AdomdDiscoveryCommandFactory>();
factoryStub.Setup(f => f.BuildExact(request))
.Returns(commandExactStub.Object);
factoryStub.Setup(f => f.BuildExternal(It.IsAny <MetadataDiscoveryRequest>()))
.Returns(commandExternalStub.Object);
var factory = factoryStub.Object;
var existsConstraint = new ExistsConstraint()
{
CommandFactory = factory
};
//Method under test
string assertionText = null;
try
{
Assert.That(request, existsConstraint);
}
catch (AssertionException ex)
{
assertionText = ex.Message;
}
//Test conclusion
Console.WriteLine(assertionText);
Assert.That(assertionText, Is.StringContaining("perspective-name").And
.StringContaining("dimension-caption").And
.StringContaining("expected-hierarchy-caption"));
}
protected global::NUnit.Framework.Constraints.Constraint InstantiateConstraint(ExistsXml ctrXml)
{
var ctr = new ExistsConstraint();
//Ignore-case if requested
if (ctrXml.IgnoreCase)
{
ctr = ctr.IgnoreCase;
}
return(ctr);
}
protected NBiConstraint InstantiateConstraint(ExistsXml ctrXml, StructureXml sutXml)
{
var expected = sutXml.Item.Caption;
var ctr = new ExistsConstraint(expected);
//Ignore-case if requested
if (ctrXml.IgnoreCase)
{
ctr = ctr.IgnoreCase;
}
return(ctr);
}
public void ExistsConstraint_ExistingPerspectiveButWrongCaseWithIgnoreCaseFalse_Failure()
{
var discovery = new DiscoveryRequestFactory().BuildDirect(
ConnectionStringReader.GetAdomd()
, DiscoveryTarget.Perspectives
, new List <IFilter>()
{
new CaptionFilter("Adventure Works".ToLower(), DiscoveryTarget.Perspectives)
});
var ctr = new ExistsConstraint();
//Method under test
Assert.Throws <AssertionException>(delegate { Assert.That(discovery, ctr); });
}
public void ExistsConstraint_ExistingPerspectiveButWrongCaseWithIgnoreCaseFalse_Failure()
{
var connection = new AdomdConnection(ConnectionStringReader.GetAdomd());
var factory = new OlapStructureDiscoveryFactory(connection);
var command = factory.Instantiate(
Target.Perspectives
, TargetType.Object
, new CaptionFilter[] {
});
var ctr = new ExistsConstraint("Adventure Works".ToLower());
//Method under test
Assert.Throws <AssertionException>(delegate { Assert.That(command, ctr); });
}
public void Matches_GivenDiscoveryRequestFailing_InvestigateCommandCalledOnce()
{
var request = new DiscoveryRequestFactory().BuildDirect(
"connectionString",
DiscoveryTarget.MeasureGroups,
new List <IFilter>()
{
new CaptionFilter("perspective-name", DiscoveryTarget.Perspectives)
, new CaptionFilter("measure-group", DiscoveryTarget.MeasureGroups)
, new CaptionFilter("measure", DiscoveryTarget.Measures)
});
var elements = new List <IField>();
var commandExactStub = new Mock <AdomdDiscoveryCommand>("connectionString");
commandExactStub.Setup(f => f.Execute())
.Returns(elements);
var commandExternalMock = new Mock <AdomdDiscoveryCommand>("connectionString");
commandExternalMock.Setup(f => f.Execute())
.Returns(elements);
var factoryStub = new Mock <AdomdDiscoveryCommandFactory>();
factoryStub.Setup(f => f.BuildExact(request))
.Returns(commandExactStub.Object);
factoryStub.Setup(f => f.BuildExternal(It.IsAny <MetadataDiscoveryRequest>()))
.Returns(commandExternalMock.Object);
var factory = factoryStub.Object;
var ctr = new ExistsConstraint()
{
CommandFactory = factory
};
//Method under test
try
{
Assert.That(request, ctr);
}
catch { }
//Test conclusion
commandExternalMock.Verify(c => c.Execute(), Times.Once());
}
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);
}
public void Matches_GivenDiscoveryRequest_CommandCalledOnce()
{
var request = new DiscoveryRequestFactory().BuildDirect(
"connectionString",
DiscoveryTarget.MeasureGroups,
new List <IFilter>()
{
new CaptionFilter("perspective-name", DiscoveryTarget.Perspectives)
, new CaptionFilter("measure-group", DiscoveryTarget.MeasureGroups)
, new CaptionFilter("measure", DiscoveryTarget.Measures)
});
var elStub = new Mock <IField>();
var el1 = elStub.Object;
var el2 = elStub.Object;
var elements = new List <IField>();
elements.Add(el1);
elements.Add(el2);
var commandMock = new Mock <AdomdDiscoveryCommand>("connectionString");
commandMock.Setup(f => f.Execute())
.Returns(elements);
var factoryStub = new Mock <AdomdDiscoveryCommandFactory>();
factoryStub.Setup(f => f.BuildExact(request))
.Returns(commandMock.Object);
var factory = factoryStub.Object;
var ctr = new ExistsConstraint()
{
CommandFactory = factory
};
//Method under test
ctr.Matches(request);
//Test conclusion
commandMock.Verify(c => c.Execute(), Times.Once());
}
public void Matches_GivenDiscoveryRequest_FactoryCalledOnceWithParametersComingFromRequest()
{
var request = new DiscoveryRequestFactory().BuildDirect(
"connectionString",
DiscoveryTarget.Dimensions,
new List <IFilter>()
{
new CaptionFilter("perspective-name", DiscoveryTarget.Perspectives)
, new CaptionFilter("expected-dimension-caption", DiscoveryTarget.Dimensions)
});
var elStub = new Mock <IField>();
var el1 = elStub.Object;
var el2 = elStub.Object;
var elements = new List <IField>();
elements.Add(el1);
elements.Add(el2);
var commandStub = new Mock <AdomdDiscoveryCommand>("connectionString");
commandStub.Setup(f => f.Execute())
.Returns(elements);
var factoryMock = new Mock <AdomdDiscoveryCommandFactory>();
factoryMock.Setup(f => f.BuildExact(request))
.Returns(commandStub.Object);
var factory = factoryMock.Object;
var ctr = new ExistsConstraint()
{
CommandFactory = factory
};
//Method under test
ctr.Matches(request);
//Test conclusion
factoryMock.Verify(f => f.BuildExact(request), Times.Once());
}
public void Matches_Default_Success()
{
var description = new CommandDescription(Target.MeasureGroups,
new CaptionFilter[]
{
new CaptionFilter(Target.Perspectives, "perspective-name")
});
var actuals = new string[] { "a", "b", "c" };
var commandStub = new Mock <IStructureDiscoveryCommand>();
commandStub.Setup(cmd => cmd.Execute()).Returns(actuals);
commandStub.Setup(cmd => cmd.Description).Returns(description);
var existsConstraint = new ExistsConstraint("a");
//Method under test
Assert.That(commandStub.Object, existsConstraint);
}
public void Matches_GivenCommand_ExecuteCalledOnce()
{
var description = new CommandDescription(Target.Dimensions,
new CaptionFilter[]
{
new CaptionFilter(Target.Perspectives, "perspective-name")
});
var actuals = new string[] { "Actual dimension 1", "Actual dimension 2", "Actual dimension 3" };
var commandMock = new Mock <IStructureDiscoveryCommand>();
commandMock.Setup(cmd => cmd.Execute()).Returns(actuals);
commandMock.Setup(cmd => cmd.Description).Returns(description);
var existConstraint = new ExistsConstraint("expected-dimension-caption");
//Method under test
existConstraint.Matches(commandMock.Object);
//Test conclusion
commandMock.Verify(cmd => cmd.Execute(), Times.Once());
}
