public void CanConditionsOverlap_WithImpliedConditions()
{
// arrange
ConditionFactory factory = new ConditionFactory();
ConditionDictionary left = factory.BuildEmpty();
ConditionDictionary right = factory.BuildEmpty();
// act
bool canOverlap = factory.CanConditionsOverlap(left, right);
// assert
canOverlap.Should().BeTrue();
}
public void GetApplicablePermutationsForTheseConditions()
{
// arrange
ConditionFactory factory = new ConditionFactory();
HashSet <ConditionKey> keys = new HashSet <ConditionKey> {
ConditionKey.DayOfWeek, ConditionKey.Season
};
ConditionDictionary conditions = factory.BuildEmpty();
// act
IEnumerable <IDictionary <ConditionKey, string> > permutations = factory.GetApplicablePermutationsForTheseConditions(keys, conditions);
// assert
IEnumerable <string> actual = permutations.Select(permutation => "(" + this.SortAndCommaDelimit(permutation.Select(p => $"{p.Key}:{p.Value}")) + ")");
List <string> expected = new List <string>();
foreach (DayOfWeek dayOfWeek in this.DaysOfWeek)
{
foreach (string season in this.Seasons)
{
expected.Add($"({ConditionKey.DayOfWeek}:{dayOfWeek}, {ConditionKey.Season}:{season})");
}
}
this.SortAndCommaDelimit(actual).Should().Be(this.SortAndCommaDelimit(expected));
}
public void CanConditionsOverlap_WhenWeathersDistinct()
{
// arrange
ConditionFactory factory = new ConditionFactory();
ConditionDictionary left = factory.BuildEmpty();
ConditionDictionary right = factory.BuildEmpty();
left.Add(ConditionKey.Weather, new[] { Weather.Rain.ToString(), Weather.Snow.ToString() });
right.Add(ConditionKey.Weather, new[] { Weather.Storm.ToString(), Weather.Sun.ToString() });
// act
bool canOverlap = factory.CanConditionsOverlap(left, right);
// assert
canOverlap.Should().BeFalse();
}
public void CanConditionsOverlap_WhenDaysAndDaysOfWeekDistinct()
{
// arrange
ConditionFactory factory = new ConditionFactory();
ConditionDictionary left = factory.BuildEmpty();
ConditionDictionary right = factory.BuildEmpty();
left.Add(ConditionKey.Day, new[] { "1", "2" });
right.Add(ConditionKey.DayOfWeek, new[] { DayOfWeek.Wednesday.ToString(), DayOfWeek.Thursday.ToString() });
// act
bool canOverlap = factory.CanConditionsOverlap(left, right);
// assert
canOverlap.Should().BeFalse();
}
public void CanConditionsOverlap_WhenSeasonsDistinct()
{
// arrange
ConditionFactory factory = new ConditionFactory();
ConditionDictionary left = factory.BuildEmpty();
ConditionDictionary right = factory.BuildEmpty();
left.Add(ConditionKey.Season, new[] { "Spring", "Summer" });
right.Add(ConditionKey.Season, new[] { "Fall", "Winter" });
// act
bool canOverlap = factory.CanConditionsOverlap(left, right);
// assert
canOverlap.Should().BeFalse();
}
public void CanConditionsOverlap_WhenSeasonsOverlap()
{
// arrange
ConditionFactory factory = new ConditionFactory();
ConditionDictionary left = factory.BuildEmpty();
ConditionDictionary right = factory.BuildEmpty();
left.Add(ConditionKey.Season, new[] { "Spring", "SUMMer" }); // should match case-insensitively
right.Add(ConditionKey.Season, new[] { "Summer", "Fall" });
// act
bool canOverlap = factory.CanConditionsOverlap(left, right);
// assert
canOverlap.Should().BeTrue();
}
public string GetPossibleStrings_WithMultipleTokens(string raw, params ConditionKey[] conditionKeys)
{
// arrange
ConditionFactory factory = new ConditionFactory();
TokenString tokenStr = new TokenString(raw, new HashSet <ConditionKey>(conditionKeys), TokenStringBuilder.TokenPattern);
ConditionDictionary conditions = factory.BuildEmpty();
// act
IEnumerable <string> actual = factory.GetPossibleStrings(tokenStr, conditions);
// assert
return(this.SortAndCommaDelimit(actual));
}
public void GetPossibleStrings_WithOneToken(ConditionKey condition)
{
// arrange
ConditionFactory factory = new ConditionFactory();
TokenString tokenStr = new TokenString("{{" + condition + "}}", new HashSet <ConditionKey> {
condition
}, TokenStringBuilder.TokenPattern);
ConditionDictionary conditions = factory.BuildEmpty();
// act
IEnumerable <string> actual = factory.GetPossibleStrings(tokenStr, conditions);
// assert
this.SortAndCommaDelimit(actual).Should().Be(this.CommaDelimitedValues[condition]);
}
public void GetPossibleValues_WithOnlyImpliedConditions()
{
// arrange
ConditionFactory factory = new ConditionFactory();
ConditionDictionary conditions = factory.BuildEmpty();
// act
IDictionary <ConditionKey, InvariantHashSet> possibleValues = factory.GetPossibleTokenisableValues(conditions);
// assert
foreach (ConditionKey key in this.TokenisableConditions)
{
this.SortAndCommaDelimit(possibleValues[key]).Should().Be(this.CommaDelimitedValues[key], $"should match for {key}");
}
}
public void GetPossibleValues_WithImpliedConditionsAndRestrictedDaysOfWeek()
{
// arrange
ConditionFactory factory = new ConditionFactory();
ConditionDictionary conditions = factory.BuildEmpty();
conditions.Add(ConditionKey.DayOfWeek, new[] { DayOfWeek.Tuesday.ToString(), DayOfWeek.Wednesday.ToString() });
// act
IDictionary <ConditionKey, InvariantHashSet> possibleValues = factory.GetPossibleTokenisableValues(conditions);
// assert
this.SortAndCommaDelimit(possibleValues[ConditionKey.Day]).Should().Be("10, 16, 17, 2, 23, 24, 3, 9", $"should match for {ConditionKey.Day}");
this.SortAndCommaDelimit(possibleValues[ConditionKey.DayOfWeek]).Should().Be($"{DayOfWeek.Tuesday}, {DayOfWeek.Wednesday}", $"should match for {ConditionKey.DayOfWeek}");
this.SortAndCommaDelimit(possibleValues[ConditionKey.Language]).Should().Be(this.CommaDelimitedValues[ConditionKey.Language], $"should match for {ConditionKey.Language}");
this.SortAndCommaDelimit(possibleValues[ConditionKey.Season]).Should().Be(this.CommaDelimitedValues[ConditionKey.Season], $"should match for {ConditionKey.Season}");
this.SortAndCommaDelimit(possibleValues[ConditionKey.Weather]).Should().Be(this.CommaDelimitedValues[ConditionKey.Weather], $"should match for {ConditionKey.Weather}");
}
public void GetPossibleValues_WithSubsetForEachCondition()
{
// arrange
ConditionFactory factory = new ConditionFactory();
ConditionDictionary conditions = factory.BuildEmpty();
conditions.Add(ConditionKey.Day, new[] { "1" /*Monday*/, "2" /*Tuesday*/, "17" /*Wednesday*/, "26" /*Friday*/, "28" /*Sunday*/ });
conditions.Add(ConditionKey.DayOfWeek, new[] { DayOfWeek.Monday.ToString(), DayOfWeek.Thursday.ToString(), DayOfWeek.Saturday.ToString(), DayOfWeek.Sunday.ToString() });
conditions.Add(ConditionKey.Language, new[] { LocalizedContentManager.LanguageCode.en.ToString(), LocalizedContentManager.LanguageCode.pt.ToString() });
conditions.Add(ConditionKey.Season, new[] { "Spring", "Fall" });
conditions.Add(ConditionKey.Weather, new InvariantHashSet {
Weather.Rain.ToString(), Weather.Sun.ToString()
});
// act
IDictionary <ConditionKey, InvariantHashSet> possibleValues = factory.GetPossibleTokenisableValues(conditions);
// assert
this.SortAndCommaDelimit(possibleValues[ConditionKey.Day]).Should().Be("1, 28", $"should match for {ConditionKey.Day}");
this.SortAndCommaDelimit(possibleValues[ConditionKey.DayOfWeek]).Should().Be($"{DayOfWeek.Monday}, {DayOfWeek.Sunday}", $"should match for {ConditionKey.DayOfWeek}");
this.SortAndCommaDelimit(possibleValues[ConditionKey.Language]).Should().Be($"{LocalizedContentManager.LanguageCode.en}, {LocalizedContentManager.LanguageCode.pt}", $"should match for {ConditionKey.Language}");
this.SortAndCommaDelimit(possibleValues[ConditionKey.Season]).Should().Be("Fall, Spring", $"should match for {ConditionKey.Season}");
this.SortAndCommaDelimit(possibleValues[ConditionKey.Weather]).Should().Be($"{Weather.Rain}, {Weather.Sun}", $"should match for {ConditionKey.Weather}");
}