public TicketIsOpenClosedConversionStrategy(IResolvesValue valueResolver)
{
if (valueResolver == null)
{
throw new ArgumentNullException(nameof(valueResolver));
}
this.valueResolver = valueResolver;
}
public HasAllLabelsConversionStrategy(IResolvesValue valueResolver)
{
if (valueResolver == null)
{
throw new ArgumentNullException(nameof(valueResolver));
}
this.valueResolver = valueResolver;
}
public void ConvertToSpecification_returns_instance_of_spec([Frozen] IResolvesValue resolver,
HasAllLabelsConversionStrategy sut,
string[] paramValues,
string[] resolvedValues)
{
// Arrange
Mock.Get(resolver)
.Setup(x => x.ResolveAll <string>(It.IsAny <IList <Value> >()))
.Returns(resolvedValues);
var criterion = Criterion.FromElementAndPredicateFunctionWithConstantValues("labels", "hasallof", paramValues);
// Act
var result = sut.ConvertToSpecification(criterion);
// Assert
Assert.That(result, Is.Not.Null);
Assert.That(result, Is.InstanceOf <HasAllLabels>());
}
public void ConvertToSpecification_from_const_returns_instance_of_spec([Frozen] IResolvesValue resolver,
HasLabelConversionStrategy sut,
string inputValue,
string resolvedValue)
{
// Arrange
Mock.Get(resolver)
.Setup(x => x.Resolve <string>(It.IsAny <Value>()))
.Returns(resolvedValue);
var criterion = Criterion.FromElementPredicateAndConstantValue("label", "=", inputValue);
// Act
var result = sut.ConvertToSpecification(criterion);
// Assert
Assert.That(result, Is.Not.Null);
Assert.That(result, Is.InstanceOf <HasLabel>());
}
public void ConvertToSpecification_from_const_resolves_value_using_resolver([Frozen] IResolvesValue resolver,
HasLabelConversionStrategy sut,
string inputValue,
string resolvedValue)
{
// Arrange
Mock.Get(resolver)
.Setup(x => x.Resolve <string>(It.IsAny <Value>()))
.Returns(resolvedValue);
var criterion = Criterion.FromElementPredicateAndConstantValue("label", "=", inputValue);
var expectedParam = ConstantValue.FromConstant(inputValue);
// Act
sut.ConvertToSpecification(criterion);
// Assert
Mock.Get(resolver).Verify(x => x.Resolve <string>(expectedParam), Times.Once);
}
public void ConvertToSpecification_resolves_all_values_using_resolver([Frozen] IResolvesValue resolver,
HasAllLabelsConversionStrategy sut,
string[] resolvedValues)
{
// Arrange
Mock.Get(resolver)
.Setup(x => x.ResolveAll <string>(It.IsAny <IList <Value> >()))
.Returns(resolvedValues);
var criterion = Criterion.FromElementAndPredicateFunctionWithConstantValues("labels", "hasallof", "one", "two");
var expectedParams = new [] {
ConstantValue.FromConstant("one"),
ConstantValue.FromConstant("two"),
}
.Cast <Value>()
.ToList();
// Act
sut.ConvertToSpecification(criterion);
// Assert
Mock.Get(resolver).Verify(x => x.ResolveAll <string>(It.Is <IList <Value> >(l => new SetEqualityComparer <Value>().Equals(l, expectedParams))), Times.Once);
}
public TicketTypeAnyOfConversionStrategy(IResolvesValue valueResolver)
{
this.valueResolver = valueResolver ?? throw new ArgumentNullException(nameof(valueResolver));
}
public void ConvertToSpecification_initialises_label_names_with_resolved_values([Frozen] IResolvesValue resolver,
HasAllLabelsConversionStrategy sut,
string[] paramValues,
string[] resolvedValues)
{
// Arrange
Mock.Get(resolver)
.Setup(x => x.ResolveAll <string>(It.IsAny <IList <Value> >()))
.Returns(resolvedValues);
var criterion = Criterion.FromElementAndPredicateFunctionWithConstantValues("labels", "hasallof", paramValues);
// Act
var result = sut.ConvertToSpecification(criterion);
// Assert
Assert.That((result as HasAllLabels)?.LabelNames, Is.EqualTo(resolvedValues));
}
public void ConvertToSpecification_returns_a_spec_when_converting_a_predicate_and_value([Frozen] IGetsStoryPointsComparisonSpec specFactory,
[Frozen] IResolvesValue resolver,
ISpecificationExpression <Ticket> spec,
StoryPointsConversionStrategy sut,
int value)
{
Mock.Get(specFactory).Setup(x => x.GetFromPredicateName(PredicateName.GreaterThan, value)).Returns(spec);
var criterion = Criterion.FromElementPredicateAndConstantValue(ElementName.StoryPoints, PredicateName.GreaterThan, value.ToString());
Mock.Get(resolver).Setup(x => x.Resolve <int>(((PredicateAndValue)criterion.Test).Value)).Returns(value);
Assert.That(() => sut.ConvertToSpecification(criterion), Is.SameAs(spec));
}
public void ConvertToSpecification_from_const_initialises_label_names_with_resolved_values([Frozen] IResolvesValue resolver,
HasLabelConversionStrategy sut,
string inputValue,
string resolvedValue)
{
// Arrange
Mock.Get(resolver)
.Setup(x => x.Resolve <string>(It.IsAny <Value>()))
.Returns(resolvedValue);
var criterion = Criterion.FromElementPredicateAndConstantValue("label", "=", inputValue);
// Act
var result = sut.ConvertToSpecification(criterion);
// Assert
Assert.That((result as HasLabel)?.LabelNames, Is.EqualTo(new [] { resolvedValue }));
}
public void ConvertToSpecification_returns_instance_of_IsOpen_if_value_is_not_closed([Frozen] IResolvesValue resolver,
TicketIsOpenClosedConversionStrategy sut,
string inputValue)
{
// Arrange
Mock.Get(resolver)
.Setup(x => x.Resolve <string>(It.IsAny <Value>()))
.Returns("somethingelse");
var criterion = Criterion.FromElementPredicateAndConstantValue("ticket", "is", inputValue);
// Act
var result = sut.ConvertToSpecification(criterion);
// Assert
Assert.That(result, Is.InstanceOf <IsOpen>());
}
public StoryPointsConversionStrategy(IResolvesValue valueResolver, IGetsStoryPointsComparisonSpec comparisonSpecFactory)
{
this.valueResolver = valueResolver ?? throw new ArgumentNullException(nameof(valueResolver));
this.comparisonSpecFactory = comparisonSpecFactory ?? throw new ArgumentNullException(nameof(comparisonSpecFactory));
}
