public void StringToDateTimeTest()
{
Assert.Equal(new DateTime(2019, 02, 11, 8, 0, 0),
TimePeriodDefinition.StringToDateTime("20190211T080000Z"));
Assert.Equal(new DateTime(2019, 03, 29, 16, 0, 0),
TimePeriodDefinition.StringToDateTime("20190329T160000Z"));
}
public static bool Check(TimePeriodDefinition td, DateTime time)
{
if ((td.StartTime.HasValue && td.StartTime > time) ||
(td.EndTime.HasValue && time > td.EndTime))
{
return(false);
}
if (td.Duration.HasValue && td.StartTime.HasValue)
{
var seconds = td.Duration.Value;
if (seconds >= new TimeSpan(24, 0, 0).TotalSeconds)
{
var endTime = td.StartTime.Value.AddSeconds(seconds);
if (time < td.StartTime || time > endTime)
{
return(false);
}
}
else
{
TimeSpan start = td.StartTime.Value.TimeOfDay;
var current = time.TimeOfDay.Subtract(start).TotalSeconds;
if (current > seconds || current < 0)
{
return(false);
}
}
}
return(td.RecurrenceRules.Aggregate(true,
(accu, current) => accu && CheckRecurrenceRule(current, time)));
}
public void TimePeriodDefinitionAssignmentNothing()
{
TimePeriodDefinition definition = "";
Assert.Null(definition.Duration);
Assert.Null(definition.StartTime);
Assert.Null(definition.EndTime);
Assert.Empty(definition.RecurrenceRules);
}
public void TestEquality()
{
TimePeriodDefinition timePeriodDefinitionA = "20181231T230000Z/63072000";
TimePeriodDefinition timePeriodDefinitionB = "20181231T230000Z/63072000";
AccessPolicy entityA = new AccessPolicy("000002oe1g25o", new NumberOfLockings(12, 45), new [] { timePeriodDefinitionA });
AccessPolicy entityB = new AccessPolicy("000002oe1g25o", new NumberOfLockings(12, 45), new [] { timePeriodDefinitionB });
Assert.Equal(entityA, entityB);
Assert.Equal(entityA.GetHashCode(), entityB.GetHashCode());
}
public LockSystemTest()
{
TimePeriodDefinition timePeriodDefinition = "20190211T080000Z/28800/DW(Mo+Tu+We+Th+Fr)/20190329T160000Z";
AccessPolicy accessPolicy = new AccessPolicy("000002oe1g25o", new NumberOfLockings(12, 45), new[] { timePeriodDefinition });
this.system = CreateEmptyLockSystem()
.AddLock(new Lock(TorWestId, "W1", null, "Tor West"))
.AddKey(new Key(KlausFenderId, "103-1", null, "Fender, Klaus"))
.AddAccessPolicy(accessPolicy);
}
public void TimePeriodDefinitionAssignmentMultiRecurence()
{
TimePeriodDefinition definition = "20190211T080000Z/28800/DWM(Su1+Su3);M(1)/20190329T160000Z";
Assert.NotNull(definition.Duration);
Assert.NotNull(definition.StartTime);
Assert.NotNull(definition.EndTime);
Assert.Equal(TimeInterval.DayOfWeekPerMonth, definition.RecurrenceRules.First().Frequency);
Assert.Equal(TimeInterval.Month, definition.RecurrenceRules.Last().Frequency);
}
public void TestCreation()
{
TimePeriodDefinition timePeriodDefinition = "20181231T230000Z/63072000";
AccessPolicy entity = new AccessPolicy("000002oe1g25o", new NumberOfLockings(12, 45), new [] { timePeriodDefinition });
Assert.Equal("000002oe1g25o", entity.Id);
Assert.Equal(12, entity.NumberOfLockings.Minimum);
Assert.Equal(45, entity.NumberOfLockings.Maximum);
Assert.Equal(63072000, entity.TimePeriodDefinitions.First().Duration);
}
public void TimePeriodDefinitionAssignmentNegation()
{
TimePeriodDefinition definition = "!20190211T080000Z/28800/DW/20190329T160000Z";
Assert.Equal(28800, definition.Duration);
Assert.Equal(new DateTime(2019, 02, 11, 8, 0, 0), definition.StartTime);
Assert.Equal(new DateTime(2019, 03, 29, 16, 0, 0), definition.EndTime);
Assert.Equal(TimeInterval.DayOfWeek, definition.RecurrenceRules.First().Frequency);
Assert.True(definition.Negation);
}
private IEnumerable <string> FormatEvent(Event @event)
{
yield return("EK");
yield return(@event.Lock.Id);
yield return(@event.EventType.Name);
yield return(TimePeriodDefinition.DateTimeToString(@event.OccurredOn));
yield return(string.Empty);
yield return(@event.Key.Id);
}
public void TestWorkingTime(string timeString, bool expected)
{
TimePeriodDefinition definition = "20190211T080000Z/28800/DW(Mo+Tu+We+Th+Fr)/20190329T160000Z";
var time = ToTime(timeString);
var actual = CheckAccess.Check(definition, time);
if (expected)
{
Assert.True(actual, timeString);
}
else
{
Assert.False(actual, timeString);
}
}
public void TestWithoutRecurrencyRule(string timeString, bool expected)
{
TimePeriodDefinition definition = "20181231T230000Z/63072000";
var time = ToTime(timeString);
var actual = CheckAccess.Check(definition, time);
if (expected)
{
Assert.True(actual, timeString);
}
else
{
Assert.False(actual, timeString);
}
}
[InlineData("2019-09-02 12:00", "WY(23+35)", false)] // 36. KW
public void TestNormal(string timeString, string rule, bool expected)
{
TimePeriodDefinition definition = $"20100101T080000Z/28800/{rule}";
var time = ToTime(timeString);
var actual = CheckAccess.Check(definition, time);
if (expected)
{
Assert.True(actual, timeString + " " + rule);
}
else
{
Assert.False(actual, timeString + " " + rule);
}
}
[InlineData("2019-01-21 12:00", false)] // Some Monday
public void TestDayWeekOfMonth(string timeString, bool expected)
{
// "2. Sonntag im Monat und Letzter Montag"
TimePeriodDefinition definition = "20190101T080000Z/28800/DWM(Su2+Mo-1)";
var time = ToTime(timeString);
var actual = CheckAccess.Check(definition, time);
if (expected)
{
Assert.True(actual, timeString);
}
else
{
Assert.False(actual, timeString);
}
}
public void TestLastDayOfYear(string timeString, bool expected)
{
// "der Monatsletzte"
TimePeriodDefinition definition = "20190101T080000Z/28800/DY(-2)";
var time = ToTime(timeString);
var actual = CheckAccess.Check(definition, time);
if (expected)
{
Assert.True(actual, timeString);
}
else
{
Assert.False(actual, timeString);
}
}
public void TestDayOfMonth(string timeString, bool expected)
{
// "1. und 15. im Monat"
TimePeriodDefinition definition = "20190101T080000Z/28800/DM(1+15)";
var time = ToTime(timeString);
var actual = CheckAccess.Check(definition, time);
if (expected)
{
Assert.True(actual, timeString);
}
else
{
Assert.False(actual, timeString);
}
}
[InlineData("2019-01-21 12:00", false)] // Montag Januar
public void TestCombinedRule(string timeString, bool expected)
{
// "Jeden Montag im Febuar"
TimePeriodDefinition definition = "20190101T080000Z/28800/DW(Mo);M(2)";
var time = ToTime(timeString);
var actual = CheckAccess.Check(definition, time);
if (expected)
{
Assert.True(actual, timeString);
}
else
{
Assert.False(actual, timeString);
}
}
public void TimePeriodIsValid(string value)
{
TimePeriodDefinition definition = value;
Assert.NotNull(definition);
}
public void TimePeriodDefinitionInvalid(string invalid)
{
// Wiederholung und Endedatum setzen Startzeit und Dauer vorraus
Assert.Throws <ArgumentNullException>(() => { TimePeriodDefinition definition = invalid; });
}
