public ReactorDummyFactory()
{
/* Add any overriding or custom registrations here. */
// ------------------------------- ENUMS --------------------------------------
AutoFixtureBackedDummyFactory.ConstrainDummyToExclude(CompositeHandlingStatusMatchStrategy.Unknown);
// ------------------------------- BASE CLASSES -------------------------------
AutoFixtureBackedDummyFactory.UseRandomInterfaceImplementationForDummy <IReactionContext>();
}
public DatabaseDummyFactory()
{
// ------------------------------- EVENTS -------------------------------------
AutoFixtureBackedDummyFactory.AddDummyCreator(
() => new HandlingForStreamDisabledEvent(
A.Dummy <UtcDateTime>(),
A.Dummy <string>()));
AutoFixtureBackedDummyFactory.AddDummyCreator(
() => new HandlingForStreamEnabledEvent(
A.Dummy <UtcDateTime>(),
A.Dummy <string>()));
AutoFixtureBackedDummyFactory.AddDummyCreator(
() => new HandlingForRecordDisabledEvent(
A.Dummy <long>(),
A.Dummy <string>(),
A.Dummy <UtcDateTime>(),
A.Dummy <string>()));
AutoFixtureBackedDummyFactory.AddDummyCreator(
() =>
{
var record = A.Dummy <StreamRecord>();
return(new RecordHandlingAvailableEvent(
record.InternalRecordId,
A.Dummy <string>(),
record,
A.Dummy <UtcDateTime>(),
A.Dummy <string>()));
});
AutoFixtureBackedDummyFactory.AddDummyCreator(
() => new RecordHandlingCanceledEvent(
A.Dummy <long>(),
A.Dummy <string>(),
A.Dummy <UtcDateTime>(),
A.Dummy <string>()));
AutoFixtureBackedDummyFactory.AddDummyCreator(
() => new RecordHandlingCompletedEvent(
A.Dummy <long>(),
A.Dummy <string>(),
A.Dummy <UtcDateTime>(),
A.Dummy <string>()));
AutoFixtureBackedDummyFactory.AddDummyCreator(
() => new RecordHandlingFailedEvent(
A.Dummy <long>(),
A.Dummy <string>(),
A.Dummy <UtcDateTime>(),
A.Dummy <string>()));
AutoFixtureBackedDummyFactory.AddDummyCreator(
() => new RecordHandlingFailureResetEvent(
A.Dummy <long>(),
A.Dummy <string>(),
A.Dummy <UtcDateTime>(),
A.Dummy <string>()));
AutoFixtureBackedDummyFactory.AddDummyCreator(
() => new RecordHandlingRunningEvent(
A.Dummy <long>(),
A.Dummy <string>(),
A.Dummy <UtcDateTime>(),
A.Dummy <string>()));
AutoFixtureBackedDummyFactory.AddDummyCreator(
() => new RecordHandlingSelfCanceledEvent(
A.Dummy <long>(),
A.Dummy <string>(),
A.Dummy <UtcDateTime>(),
A.Dummy <string>()));
AutoFixtureBackedDummyFactory.AddDummyCreator(
() => new PruneOperationExecutedEvent(
A.Dummy <IPruneOp>(),
A.Dummy <PruneSummary>(),
A.Dummy <UtcDateTime>()));
AutoFixtureBackedDummyFactory.AddDummyCreator(
() => new PruneOperationRequestedEvent(
A.Dummy <IPruneOp>(),
A.Dummy <UtcDateTime>()));
AutoFixtureBackedDummyFactory.AddDummyCreator(
() => new PruneRequestCanceledEvent(
A.Dummy <string>(),
A.Dummy <UtcDateTime>()));
AutoFixtureBackedDummyFactory.AddDummyCreator(
() => new UniqueLongIssuedEvent(
A.Dummy <long>(),
A.Dummy <UtcDateTime>(),
A.Dummy <string>()));
AutoFixtureBackedDummyFactory.AddDummyCreator(
() =>
{
var result = new IdDeprecatedEvent(
A.Dummy <UtcDateTime>(),
A.Dummy <string>());
return(result);
});
AutoFixtureBackedDummyFactory.AddDummyCreator(
() => new IdDeprecatedEvent <Version, Version>(
A.Dummy <Version>(),
A.Dummy <UtcDateTime>(),
A.Dummy <string>()));
AutoFixtureBackedDummyFactory.AddDummyCreator(
() => new IdDeprecatedEvent <Version>(
A.Dummy <UtcDateTime>(),
A.Dummy <string>()));
// ------------------------------- MODELS -------------------------------------
AutoFixtureBackedDummyFactory.AddDummyCreator(
() => new StreamRecordHandlingEntry(
A.Dummy <long>(),
A.Dummy <long>(),
A.Dummy <string>(),
A.Dummy <HandlingStatus>(),
A.Dummy <IReadOnlyCollection <NamedValue <string> > >(),
A.Dummy <string>(),
A.Dummy <UtcDateTime>()));
AutoFixtureBackedDummyFactory.AddDummyCreator(
() =>
{
var scenario = ThreadSafeRandom.Next(1, 4);
switch (scenario)
{
case 1:
return(new CreateStreamResult(false, true));
case 2:
return(new CreateStreamResult(true, false));
case 3:
return(new CreateStreamResult(true, true));
default:
throw new NotSupportedException(
FormattableString.Invariant($"Invalid scenario {scenario} for creating a dummy {nameof(CreateStreamResult)}."));
}
});
AutoFixtureBackedDummyFactory.AddDummyCreator(
() => new StreamRecordMetadata(
A.Dummy <string>(),
A.Dummy <SerializerRepresentation>(),
A.Dummy <TypeRepresentationWithAndWithoutVersion>(),
A.Dummy <TypeRepresentationWithAndWithoutVersion>(),
A.Dummy <IReadOnlyCollection <NamedValue <string> > >(),
A.Dummy <UtcDateTime>(),
A.Dummy <UtcDateTime>()));
AutoFixtureBackedDummyFactory.AddDummyCreator(
() => new StreamRecordMetadata <Version>(
A.Dummy <Version>(),
A.Dummy <SerializerRepresentation>(),
A.Dummy <TypeRepresentationWithAndWithoutVersion>(),
A.Dummy <TypeRepresentationWithAndWithoutVersion>(),
A.Dummy <IReadOnlyCollection <NamedValue <string> > >(),
A.Dummy <UtcDateTime>(),
A.Dummy <UtcDateTime>()));
AutoFixtureBackedDummyFactory.AddDummyCreator(
() => new GetStreamFromRepresentationOp <FileStreamRepresentation, MemoryStandardStream>(
A.Dummy <FileStreamRepresentation>()));
AutoFixtureBackedDummyFactory.AddDummyCreator(
() =>
{
var scenario = ThreadSafeRandom.Next(1, 5);
switch (scenario)
{
case 1:
return(new PutRecordResult(A.Dummy <long>(), null));
case 2:
return(new PutRecordResult(null, Some.ReadOnlyDummies <long>().ToList()));
case 3:
return(new PutRecordResult(null, Some.ReadOnlyDummies <long>().ToList(), Some.ReadOnlyDummies <long>().ToList()));
case 4:
return(new PutRecordResult(A.Dummy <long>(), Some.ReadOnlyDummies <long>().ToList(), Some.ReadOnlyDummies <long>().ToList()));
default:
throw new NotSupportedException(FormattableString.Invariant($"Invalid scenario {scenario} for creating a dummy {nameof(PutRecordResult)}."));
}
});
AutoFixtureBackedDummyFactory.AddDummyCreator(
() =>
{
var scenario = ThreadSafeRandom.Next(1, 4);
switch (scenario)
{
case 1:
return(new TryHandleRecordResult(null, false));
case 2:
return(new TryHandleRecordResult(A.Dummy <StreamRecord>(), false));
case 3:
return(new TryHandleRecordResult(null, true));
default:
throw new NotSupportedException(FormattableString.Invariant($"Invalid scenario {scenario} for creating a dummy {nameof(TryHandleRecordResult)}."));
}
});
// ------------------------------- ENUMS --------------------------------------
AutoFixtureBackedDummyFactory.ConstrainDummyToBeOneOf(VersionMatchStrategy.Any, VersionMatchStrategy.SpecifiedVersion);
AutoFixtureBackedDummyFactory.ConstrainDummyToExclude(CompositeHandlingStatus.Unknown);
AutoFixtureBackedDummyFactory.ConstrainDummyToExclude(ExistingDatabaseStrategy.Unknown);
AutoFixtureBackedDummyFactory.ConstrainDummyToExclude(ExistingRecordStrategy.Unknown);
AutoFixtureBackedDummyFactory.ConstrainDummyToExclude(ExistingStreamStrategy.Unknown);
AutoFixtureBackedDummyFactory.ConstrainDummyToExclude(HandlingStatus.Unknown);
AutoFixtureBackedDummyFactory.ConstrainDummyToExclude(OrderRecordsBy.Unknown);
AutoFixtureBackedDummyFactory.ConstrainDummyToExclude(RecordNotFoundStrategy.Unknown);
AutoFixtureBackedDummyFactory.ConstrainDummyToExclude(StreamNotFoundStrategy.Unknown);
AutoFixtureBackedDummyFactory.ConstrainDummyToExclude(StreamRecordItemsToInclude.Unknown);
AutoFixtureBackedDummyFactory.ConstrainDummyToExclude(TagMatchStrategy.Unknown);
// ------------------------------- MODEL INTERFACES --------------------------------------
AutoFixtureBackedDummyFactory.UseRandomInterfaceImplementationForDummy <IResourceLocator>();
AutoFixtureBackedDummyFactory.UseRandomInterfaceImplementationForDummy <IStreamRepresentation>();
// ------------------------------- OPERATIONS -------------------------------------
AutoFixtureBackedDummyFactory.AddDummyCreator(
() => new PruneBeforeInternalRecordDateOp(
A.Dummy <UtcDateTime>(),
A.Dummy <string>()));
AutoFixtureBackedDummyFactory.AddDummyCreator(
() => new StandardPruneStreamOp(
A.Dummy <long>(),
A.Dummy <UtcDateTime>(),
A.Dummy <string>(),
A.Dummy <IResourceLocator>()));
AutoFixtureBackedDummyFactory.AddDummyCreator(
() => new StandardUpdateHandlingStatusForRecordOp(
A.Dummy <long>(),
A.Dummy <string>(),
A.Dummy <HandlingStatus>().ThatIsNot(HandlingStatus.DisabledForStream),
Some.ReadOnlyDummies <HandlingStatus>().ToList(),
A.Dummy <string>(),
Some.ReadOnlyDummies <NamedValue <string> >().ToList(),
A.Dummy <bool>(),
A.Dummy <IResourceLocator>()));
AutoFixtureBackedDummyFactory.AddDummyCreator(
() => new StandardUpdateHandlingStatusForStreamOp(
A.Dummy <HandlingStatus>().ThatIsIn(new[] { HandlingStatus.DisabledForStream, HandlingStatus.AvailableByDefault }),
A.Dummy <string>(),
Some.ReadOnlyDummies <NamedValue <string> >().ToList(),
A.Dummy <IResourceLocator>()));
AutoFixtureBackedDummyFactory.AddDummyCreator(
() =>
{
var existingRecordStrategy = A.Dummy <ExistingRecordStrategy>();
var result = new PutAndReturnInternalRecordIdOp <Version>(
A.Dummy <Version>(),
A.Dummy <IReadOnlyCollection <NamedValue <string> > >(),
existingRecordStrategy,
existingRecordStrategy == ExistingRecordStrategy.PruneIfFoundById || existingRecordStrategy == ExistingRecordStrategy.PruneIfFoundByIdAndType
? (int?)A.Dummy <ZeroOrPositiveInteger>()
: null,
A.Dummy <VersionMatchStrategy>());
return(result);
});
AutoFixtureBackedDummyFactory.AddDummyCreator(
() =>
{
var existingRecordStrategy = A.Dummy <ExistingRecordStrategy>();
var result = new PutOp <Version>(
A.Dummy <Version>(),
A.Dummy <IReadOnlyCollection <NamedValue <string> > >(),
existingRecordStrategy,
existingRecordStrategy == ExistingRecordStrategy.PruneIfFoundById || existingRecordStrategy == ExistingRecordStrategy.PruneIfFoundByIdAndType
? (int?)A.Dummy <ZeroOrPositiveInteger>()
: null,
A.Dummy <VersionMatchStrategy>());
return(result);
});
AutoFixtureBackedDummyFactory.AddDummyCreator(
() =>
{
var existingRecordStrategy = A.Dummy <ExistingRecordStrategy>();
var result = new PutWithIdAndReturnInternalRecordIdOp <Version, Version>(
A.Dummy <Version>(),
A.Dummy <Version>(),
A.Dummy <IReadOnlyCollection <NamedValue <string> > >(),
existingRecordStrategy,
existingRecordStrategy == ExistingRecordStrategy.PruneIfFoundById || existingRecordStrategy == ExistingRecordStrategy.PruneIfFoundByIdAndType
? (int?)A.Dummy <ZeroOrPositiveInteger>()
: null,
A.Dummy <VersionMatchStrategy>());
return(result);
});
AutoFixtureBackedDummyFactory.AddDummyCreator(
() =>
{
var existingRecordStrategy = A.Dummy <ExistingRecordStrategy>();
var result = new PutWithIdOp <Version, Version>(
A.Dummy <Version>(),
A.Dummy <Version>(),
A.Dummy <IReadOnlyCollection <NamedValue <string> > >(),
existingRecordStrategy,
existingRecordStrategy == ExistingRecordStrategy.PruneIfFoundById || existingRecordStrategy == ExistingRecordStrategy.PruneIfFoundByIdAndType
? (int?)A.Dummy <ZeroOrPositiveInteger>()
: null,
A.Dummy <VersionMatchStrategy>());
return(result);
});
AutoFixtureBackedDummyFactory.AddDummyCreator(
() =>
{
var existingRecordStrategy = A.Dummy <ExistingRecordStrategy>();
var result = new StandardPutRecordOp(
A.Dummy <StreamRecordMetadata>(),
A.Dummy <DescribedSerializationBase>(),
existingRecordStrategy,
existingRecordStrategy == ExistingRecordStrategy.PruneIfFoundById || existingRecordStrategy == ExistingRecordStrategy.PruneIfFoundByIdAndType
? (int?)A.Dummy <ZeroOrPositiveInteger>()
: null,
A.Dummy <VersionMatchStrategy>(),
A.Dummy <long?>(),
A.Dummy <IResourceLocator>());
return(result);
});
// ------------------------------- OPERATION INTERFACES -------------------------------------
AutoFixtureBackedDummyFactory.UseRandomInterfaceImplementationForDummy <IPruneOp>();
}
public AccountingTimeDummyFactory()
{
AutoFixtureBackedDummyFactory.ConstrainDummyToExclude(DayOfMonth.Invalid);
AutoFixtureBackedDummyFactory.ConstrainDummyToExclude(MonthNumber.Invalid);
AutoFixtureBackedDummyFactory.ConstrainDummyToExclude(MonthOfYear.Invalid);
AutoFixtureBackedDummyFactory.ConstrainDummyToExclude(QuarterNumber.Invalid);
AutoFixtureBackedDummyFactory.ConstrainDummyToExclude(UnitOfTimeKind.Invalid);
AutoFixtureBackedDummyFactory.ConstrainDummyToExclude(UnitOfTimeGranularity.Invalid);
AutoFixtureBackedDummyFactory.ConstrainDummyToExclude(ReportingPeriodComponent.Invalid);
AutoFixtureBackedDummyFactory.UseRandomConcreteSubclassForDummy <UnitOfTime>();
AutoFixtureBackedDummyFactory.UseRandomConcreteSubclassForDummy <CalendarUnitOfTime>();
AutoFixtureBackedDummyFactory.UseRandomConcreteSubclassForDummy <FiscalUnitOfTime>();
AutoFixtureBackedDummyFactory.UseRandomConcreteSubclassForDummy <GenericUnitOfTime>();
AutoFixtureBackedDummyFactory.UseRandomInterfaceImplementationForDummy <IHaveAMonth>();
AutoFixtureBackedDummyFactory.UseRandomInterfaceImplementationForDummy <IHaveAQuarter>();
AutoFixtureBackedDummyFactory.UseRandomInterfaceImplementationForDummy <IHaveAYear>();
AutoFixtureBackedDummyFactory.UseRandomInterfaceImplementationForDummy <IAmBoundedTime>();
AutoFixtureBackedDummyFactory.UseRandomInterfaceImplementationForDummy <IAmUnboundedTime>();
AutoFixtureBackedDummyFactory.AddDummyCreator(
() =>
{
var year = ThreadSafeRandom.Next(MinYear, MaxYear + 1);
var result = new GenericMonth(year, A.Dummy <MonthNumber>());
return(result);
});
AutoFixtureBackedDummyFactory.AddDummyCreator(
() =>
{
var year = ThreadSafeRandom.Next(MinYear, MaxYear + 1);
var result = new GenericQuarter(year, A.Dummy <QuarterNumber>());
return(result);
});
AutoFixtureBackedDummyFactory.AddDummyCreator(
() =>
{
var year = ThreadSafeRandom.Next(MinYear, MaxYear + 1);
var result = new GenericYear(year);
return(result);
});
AutoFixtureBackedDummyFactory.AddDummyCreator(
() =>
{
var year = ThreadSafeRandom.Next(MinYear, MaxYear + 1);
var result = new FiscalMonth(year, A.Dummy <MonthNumber>());
return(result);
});
AutoFixtureBackedDummyFactory.AddDummyCreator(
() =>
{
var year = ThreadSafeRandom.Next(MinYear, MaxYear + 1);
var result = new FiscalQuarter(year, A.Dummy <QuarterNumber>());
return(result);
});
AutoFixtureBackedDummyFactory.AddDummyCreator(
() =>
{
var year = ThreadSafeRandom.Next(MinYear, MaxYear + 1);
var result = new FiscalYear(year);
return(result);
});
AutoFixtureBackedDummyFactory.AddDummyCreator(
() =>
{
while (true)
{
try
{
var date = A.Dummy <DateTime>();
var year = ThreadSafeRandom.Next(MinYear, MaxYear + 1);
var result = new CalendarDay(year, (MonthOfYear)date.Month, (DayOfMonth)date.Day);
return(result);
}
catch (ArgumentException)
{
}
}
});
AutoFixtureBackedDummyFactory.AddDummyCreator(
() =>
{
var year = ThreadSafeRandom.Next(MinYear, MaxYear + 1);
var result = new CalendarMonth(year, A.Dummy <MonthOfYear>());
return(result);
});
AutoFixtureBackedDummyFactory.AddDummyCreator(
() =>
{
var year = ThreadSafeRandom.Next(MinYear, MaxYear + 1);
var result = new CalendarQuarter(year, A.Dummy <QuarterNumber>());
return(result);
});
AutoFixtureBackedDummyFactory.AddDummyCreator(
() =>
{
var year = ThreadSafeRandom.Next(MinYear, MaxYear + 1);
var result = new CalendarYear(year);
return(result);
});
AddDummyCreatorForAbstractReportingPeriod <UnitOfTime>();
AddDummyCreatorForAbstractReportingPeriod <CalendarUnitOfTime>();
AddDummyCreatorForAbstractReportingPeriod <FiscalUnitOfTime>();
AddDummyCreatorForAbstractReportingPeriod <GenericUnitOfTime>();
AddDummyCreatorForConcreteReportingPeriod <CalendarDay>();
AddDummyCreatorForConcreteReportingPeriod <CalendarQuarter>();
AddDummyCreatorForConcreteReportingPeriod <CalendarMonth>();
AddDummyCreatorForConcreteReportingPeriod <CalendarYear>();
AddDummyCreatorForConcreteReportingPeriod <CalendarUnbounded>();
AddDummyCreatorForConcreteReportingPeriod <FiscalMonth>();
AddDummyCreatorForConcreteReportingPeriod <FiscalQuarter>();
AddDummyCreatorForConcreteReportingPeriod <FiscalYear>();
AddDummyCreatorForConcreteReportingPeriod <FiscalUnbounded>();
AddDummyCreatorForConcreteReportingPeriod <GenericMonth>();
AddDummyCreatorForConcreteReportingPeriod <GenericQuarter>();
AddDummyCreatorForConcreteReportingPeriod <GenericYear>();
AddDummyCreatorForConcreteReportingPeriod <GenericUnbounded>();
}
public NotificationDummyFactory()
{
/* Add any overriding or custom registrations here. */
// enums
AutoFixtureBackedDummyFactory.ConstrainDummyToExclude(CannotPrepareToSendOnChannelAction.Unknown);
AutoFixtureBackedDummyFactory.ConstrainDummyToExclude(DeliveryChannelAction.Unknown);
AutoFixtureBackedDummyFactory.ConstrainDummyToExclude(FailureAction.Unknown);
AutoFixtureBackedDummyFactory.ConstrainDummyToExclude(PrepareToSendOnChannelFailureAction.Unknown);
AutoFixtureBackedDummyFactory.ConstrainDummyToExclude(AttemptToSendNotificationOutcome.Unknown);
AutoFixtureBackedDummyFactory.ConstrainDummyToExclude(ChannelOperationOutcome.Unknown);
AutoFixtureBackedDummyFactory.ConstrainDummyToExclude(GetAudienceOutcome.Unknown);
AutoFixtureBackedDummyFactory.ConstrainDummyToExclude(GetDeliveryChannelConfigsOutcome.Unknown);
AutoFixtureBackedDummyFactory.ConstrainDummyToExclude(PrepareToSendNotificationOutcome.Unknown);
AutoFixtureBackedDummyFactory.ConstrainDummyToExclude(PrepareToSendOnChannelOutcome.Unknown);
// interfaces
AutoFixtureBackedDummyFactory.AddDummyCreator <IOperation>(A.Dummy <OperationBase>);// remove when moved to Protocol Dummy Factory
AutoFixtureBackedDummyFactory.UseRandomInterfaceImplementationForDummy <IAudience>();
AutoFixtureBackedDummyFactory.UseRandomInterfaceImplementationForDummy <IDeliveryChannel>();
AutoFixtureBackedDummyFactory.UseRandomInterfaceImplementationForDummy <IFailure>();
AutoFixtureBackedDummyFactory.UseRandomInterfaceImplementationForDummy <INotification>();
// events
AutoFixtureBackedDummyFactory.AddDummyCreator(() => new CouldNotSendOnAnyPreparedChannelEvent(
A.Dummy <long>(),
A.Dummy <UtcDateTime>(),
A.Dummy <AttemptToSendNotificationResult>().Whose(_ => _.GetOutcome() == AttemptToSendNotificationOutcome.CouldNotSendOnAnyPreparedChannel)));
AutoFixtureBackedDummyFactory.AddDummyCreator(() => new SentOnAllPreparedChannelsEvent(
A.Dummy <long>(),
A.Dummy <UtcDateTime>(),
A.Dummy <AttemptToSendNotificationResult>().Whose(_ => _.GetOutcome() == AttemptToSendNotificationOutcome.SentOnAllPreparedChannels)));
AutoFixtureBackedDummyFactory.AddDummyCreator(() => new SentOnSomePreparedChannelsEvent(
A.Dummy <long>(),
A.Dummy <UtcDateTime>(),
A.Dummy <AttemptToSendNotificationResult>().Whose(_ => _.GetOutcome() == AttemptToSendNotificationOutcome.SentOnSomePreparedChannels)));
AutoFixtureBackedDummyFactory.AddDummyCreator(() => new CouldNotGetOrUseAudienceEvent(
A.Dummy <long>(),
A.Dummy <UtcDateTime>(),
A.Dummy <GetAudienceResult>().Whose(_ => (_.GetOutcome() != GetAudienceOutcome.GotAudienceWithNoFailuresReported) && (_.GetOutcome() != GetAudienceOutcome.GotAudienceWithReportedFailuresIgnored))));
AutoFixtureBackedDummyFactory.AddDummyCreator(() => new CouldNotGetOrUseDeliveryChannelConfigsEvent(
A.Dummy <long>(),
A.Dummy <UtcDateTime>(),
GetPassingAudienceResult(),
A.Dummy <GetDeliveryChannelConfigsResult>().Whose(_ => (_.GetOutcome() != GetDeliveryChannelConfigsOutcome.GotDeliveryChannelConfigsWithNoFailuresReported) && (_.GetOutcome() != GetDeliveryChannelConfigsOutcome.GotDeliveryChannelConfigsWithReportedFailuresIgnored))));
AutoFixtureBackedDummyFactory.AddDummyCreator(() => new AudienceOptedOutOfAllChannelsEvent(
A.Dummy <long>(),
A.Dummy <UtcDateTime>(),
GetPassingAudienceResult(),
GetPassingDeliveryChannelConfigsResult(),
A.Dummy <PrepareToSendNotificationResult>().Whose(_ => (_.GetOutcome() == PrepareToSendNotificationOutcome.AudienceOptedOutOfAllChannels))));
AutoFixtureBackedDummyFactory.AddDummyCreator(() => new CouldNotPrepareToSendOnAnyChannelEvent(
A.Dummy <long>(),
A.Dummy <UtcDateTime>(),
GetPassingAudienceResult(),
GetPassingDeliveryChannelConfigsResult(),
A.Dummy <PrepareToSendNotificationResult>().Whose(_ => (_.GetOutcome() == PrepareToSendNotificationOutcome.CouldNotPrepareToSendOnAnyChannelDespiteAttemptingAll) || (_.GetOutcome() == PrepareToSendNotificationOutcome.CouldNotPrepareToSendOnAnyChannelBecauseOneForcedAllToBeDiscarded))));
AutoFixtureBackedDummyFactory.AddDummyCreator(() => new PreparedToSendOnAllChannelsEvent(
A.Dummy <long>(),
A.Dummy <UtcDateTime>(),
GetPassingAudienceResult(),
GetPassingDeliveryChannelConfigsResult(),
A.Dummy <PrepareToSendNotificationResult>().Whose(_ => (_.GetOutcome() == PrepareToSendNotificationOutcome.PreparedToSendOnAllChannels))));
AutoFixtureBackedDummyFactory.AddDummyCreator(() => new PreparedToSendOnSomeChannelsEvent(
A.Dummy <long>(),
A.Dummy <UtcDateTime>(),
GetPassingAudienceResult(),
GetPassingDeliveryChannelConfigsResult(),
A.Dummy <PrepareToSendNotificationResult>().Whose(_ => (_.GetOutcome() == PrepareToSendNotificationOutcome.PreparedToSendOnSomeChannels))));
AutoFixtureBackedDummyFactory.AddDummyCreator(() => new SendNotificationRequestedEvent(
A.Dummy <long>(),
A.Dummy <UtcDateTime>(),
A.Dummy <SendNotificationOp>()));
// model classes
AutoFixtureBackedDummyFactory.AddDummyCreator(() =>
{
var channelToOperationsOutcomeInfoMap = new Dictionary <IDeliveryChannel, IReadOnlyCollection <ChannelOperationOutcomeInfo> >();
var randomIndex = ThreadSafeRandom.Next(1, 4);
var randomChannels = new IDeliveryChannel[] { new SlackDeliveryChannel(), new EmailDeliveryChannel() }.RandomizeElements().ToArray();
if (randomIndex == 1)
{
// SentOnAllPreparedChannels
randomChannels = randomChannels.Take(ThreadSafeRandom.Next(1, randomChannels.Length + 1)).ToArray();
foreach (var randomChannel in randomChannels)
{
channelToOperationsOutcomeInfoMap.Add(
randomChannel,
Some.ReadOnlyDummies <ChannelOperationOutcomeInfo>().Whose(_ => _.All(o => o.Outcome == ChannelOperationOutcome.Succeeded)).ToList());
}
}
else if (randomIndex == 2)
{
// SentOnSomePreparedChannels
channelToOperationsOutcomeInfoMap.Add(
randomChannels[0],
Some.ReadOnlyDummies <ChannelOperationOutcomeInfo>().Whose(_ => _.Select(o => o.Outcome).Distinct().Count() > 1).ToList());
channelToOperationsOutcomeInfoMap.Add(
randomChannels[1],
Some.ReadOnlyDummies <ChannelOperationOutcomeInfo>().Whose(_ => _.All(o => o.Outcome == ChannelOperationOutcome.Succeeded)).ToList());
}
else
{
// CouldNotSendOnAnyPreparedChannel
channelToOperationsOutcomeInfoMap.Add(
randomChannels[0],
Some.ReadOnlyDummies <ChannelOperationOutcomeInfo>().Whose(_ => _.Select(o => o.Outcome).Distinct().Count() > 1).ToList());
channelToOperationsOutcomeInfoMap.Add(
randomChannels[1],
Some.ReadOnlyDummies <ChannelOperationOutcomeInfo>().Whose(_ => _.All(o => o.Outcome == ChannelOperationOutcome.Failed)).ToList());
}
var result = new AttemptToSendNotificationResult(channelToOperationsOutcomeInfoMap);
return(result);
});
AutoFixtureBackedDummyFactory.AddDummyCreator(() =>
{
var randomIndex = ThreadSafeRandom.Next(1, 6);
GetAudienceResult result;
if (randomIndex == 1)
{
// GotAudienceWithNoFailuresReported
result = new GetAudienceResult(A.Dummy <IAudience>(), null, A.Dummy <FailureAction>());
}
else if (randomIndex == 2)
{
// GotAudienceWithReportedFailuresIgnored
result = new GetAudienceResult(A.Dummy <IAudience>(), Some.ReadOnlyDummies <IFailure>().ToList(), FailureAction.IgnoreAndProceedIfPossibleOtherwiseStop);
}
else if (randomIndex == 3)
{
// CouldNotGetAudienceAndNoFailuresReported
if (ThreadSafeRandom.Next(2) == 0)
{
result = new GetAudienceResult(null, null, A.Dummy <FailureAction>());
}
else
{
result = new GetAudienceResult(null, new IFailure[0], A.Dummy <FailureAction>());
}
}
else if (randomIndex == 4)
{
// CouldNotGetAudienceWithSomeFailuresReported
result = new GetAudienceResult(null, Some.ReadOnlyDummies <IFailure>().ToList(), A.Dummy <FailureAction>());
}
else
{
// DespiteGettingAudienceFailuresPreventUsingIt
result = new GetAudienceResult(A.Dummy <IAudience>(), Some.ReadOnlyDummies <IFailure>().ToList(), FailureAction.Stop);
}
return(result);
});
AutoFixtureBackedDummyFactory.AddDummyCreator(() =>
{
var randomChannels = new IDeliveryChannel[] { new SlackDeliveryChannel(), new EmailDeliveryChannel() };
randomChannels = randomChannels.RandomizeElements().Take(ThreadSafeRandom.Next(1, randomChannels.Length + 1)).ToArray();
var deliveryChannelConfigs = randomChannels.Select(_ => new DeliveryChannelConfig(_, A.Dummy <DeliveryChannelAction>())).ToList();
var randomIndex = ThreadSafeRandom.Next(1, 6);
GetDeliveryChannelConfigsResult result;
if (randomIndex == 1)
{
// GotDeliveryChannelConfigsWithNoFailuresReported
result = new GetDeliveryChannelConfigsResult(
deliveryChannelConfigs,
null,
A.Dummy <FailureAction>());
}
else if (randomIndex == 2)
{
// GotDeliveryChannelConfigsWithReportedFailuresIgnored
result = new GetDeliveryChannelConfigsResult(
deliveryChannelConfigs,
Some.ReadOnlyDummies <IFailure>().ToList(),
FailureAction.IgnoreAndProceedIfPossibleOtherwiseStop);
}
else if (randomIndex == 3)
{
// CouldNotGetDeliveryChannelConfigsAndNoFailuresReported
result = new GetDeliveryChannelConfigsResult(null, null, A.Dummy <FailureAction>());
}
else if (randomIndex == 4)
{
// CouldNotGetDeliveryChannelConfigsWithSomeFailuresReported
result = new GetDeliveryChannelConfigsResult(null, Some.ReadOnlyDummies <IFailure>().ToList(), A.Dummy <FailureAction>());
}
else
{
// DespiteGettingDeliveryChannelConfigsFailuresPreventUsingThem
result = new GetDeliveryChannelConfigsResult(
deliveryChannelConfigs,
Some.ReadOnlyDummies <IFailure>().ToList(),
FailureAction.Stop);
}
return(result);
});
AutoFixtureBackedDummyFactory.AddDummyCreator(() =>
{
var randomChannels = new IDeliveryChannel[] { new SlackDeliveryChannel(), new EmailDeliveryChannel() }.RandomizeElements().ToArray();
var randomIndex = ThreadSafeRandom.Next(1, 6);
PrepareToSendNotificationResult result;
if (randomIndex == 1)
{
// AudienceOptedOutOfAllChannels
result = new PrepareToSendNotificationResult(
new Dictionary <IDeliveryChannel, PrepareToSendOnChannelResult>(),
A.Dummy <CannotPrepareToSendOnChannelAction>(),
new IDeliveryChannel[0]);
}
else if (randomIndex == 2)
{
// PreparedToSendOnAllChannels
var channelToPrepareToSendOnChannelResultMap = new Dictionary <IDeliveryChannel, PrepareToSendOnChannelResult>();
foreach (var randomChannel in randomChannels)
{
channelToPrepareToSendOnChannelResultMap.Add(
randomChannel,
new PrepareToSendOnChannelResult(GetChannelOperationInstructions(), null, A.Dummy <PrepareToSendOnChannelFailureAction>()));
}
result = new PrepareToSendNotificationResult(
channelToPrepareToSendOnChannelResultMap,
A.Dummy <CannotPrepareToSendOnChannelAction>(),
randomChannels);
}
else if (randomIndex == 3)
{
// PreparedToSendOnSomeChannels
result = new PrepareToSendNotificationResult(
new Dictionary <IDeliveryChannel, PrepareToSendOnChannelResult>
{
{
randomChannels[0],
new PrepareToSendOnChannelResult(
GetChannelOperationInstructions(),
Some.ReadOnlyDummies <IFailure>().ToList(),
PrepareToSendOnChannelFailureAction.IgnoreAndProceedIfPossibleOtherwiseDoNotSendOnChannel)
},
{
randomChannels[1],
new PrepareToSendOnChannelResult(
null,
null,
PrepareToSendOnChannelFailureAction.IgnoreAndProceedIfPossibleOtherwiseDoNotSendOnChannel)
},
},
CannotPrepareToSendOnChannelAction.ContinueAndAttemptPreparingToSendOnNextChannel,
new IDeliveryChannel[] { randomChannels[0] });
}
else if (randomIndex == 4)
{
// CouldNotPrepareToSendOnAnyChannelDespiteAttemptingAll
result = new PrepareToSendNotificationResult(
new Dictionary <IDeliveryChannel, PrepareToSendOnChannelResult>
{
{
new SlackDeliveryChannel(),
new PrepareToSendOnChannelResult(
null,
null,
PrepareToSendOnChannelFailureAction.IgnoreAndProceedIfPossibleOtherwiseDoNotSendOnChannel)
},
{
new EmailDeliveryChannel(),
new PrepareToSendOnChannelResult(
GetChannelOperationInstructions(),
Some.ReadOnlyDummies <IFailure>().ToList(),
PrepareToSendOnChannelFailureAction.DoNotSendOnChannel)
},
},
CannotPrepareToSendOnChannelAction.ContinueAndAttemptPreparingToSendOnNextChannel,
new IDeliveryChannel[0]);
}
else
{
// CouldNotPrepareToSendOnAnyChannelBecauseOneForcedAllToBeDiscarded
result = new PrepareToSendNotificationResult(
new Dictionary <IDeliveryChannel, PrepareToSendOnChannelResult>
{
{
randomChannels[0],
new PrepareToSendOnChannelResult(
GetChannelOperationInstructions(),
Some.ReadOnlyDummies <IFailure>().ToList(),
PrepareToSendOnChannelFailureAction.DoNotSendOnChannel)
},
},
CannotPrepareToSendOnChannelAction.StopAndNotDoNotSendOnAnyChannel,
new IDeliveryChannel[0]);
}
return(result);
});
AutoFixtureBackedDummyFactory.AddDummyCreator(() =>
{
var randomIndex = ThreadSafeRandom.Next(1, 6);
PrepareToSendOnChannelResult result;
if (randomIndex == 1)
{
// PreparedToSendOnChannelWithNoFailuresReported
result = new PrepareToSendOnChannelResult(
GetChannelOperationInstructions(),
null,
A.Dummy <PrepareToSendOnChannelFailureAction>());
}
else if (randomIndex == 2)
{
// PreparedToSendOnChannelWithReportedFailuresIgnored
result = new PrepareToSendOnChannelResult(
GetChannelOperationInstructions(),
Some.ReadOnlyDummies <IFailure>().ToList(),
PrepareToSendOnChannelFailureAction.IgnoreAndProceedIfPossibleOtherwiseDoNotSendOnChannel);
}
else if (randomIndex == 3)
{
// CouldNotPrepareToSendOnChannelAndNoFailuresReported
if (ThreadSafeRandom.Next(2) == 0)
{
result = new PrepareToSendOnChannelResult(
null,
null,
PrepareToSendOnChannelFailureAction.IgnoreAndProceedIfPossibleOtherwiseDoNotSendOnChannel);
}
else
{
result = new PrepareToSendOnChannelResult(
new ChannelOperationInstruction[0],
new IFailure[0],
PrepareToSendOnChannelFailureAction.IgnoreAndProceedIfPossibleOtherwiseDoNotSendOnChannel);
}
}
else if (randomIndex == 4)
{
// CouldNotPrepareToSendOnChannelWithSomeFailuresReported
result = new PrepareToSendOnChannelResult(
null,
Some.ReadOnlyDummies <IFailure>().ToList(),
PrepareToSendOnChannelFailureAction.IgnoreAndProceedIfPossibleOtherwiseDoNotSendOnChannel);
}
else
{
// DespitePreparingToSendOnChannelFailuresPreventUsingIt
result = new PrepareToSendOnChannelResult(
GetChannelOperationInstructions(),
Some.ReadOnlyDummies <IFailure>().ToList(),
PrepareToSendOnChannelFailureAction.DoNotSendOnChannel);
}
return(result);
});
AutoFixtureBackedDummyFactory.AddDummyCreator(() =>
{
var succeededEventType = A.Dummy <TypeRepresentation>();
var failedEventType = A.Dummy <TypeRepresentation>().ThatIsNot(succeededEventType);
var result = new ChannelOperationMonitoringInfo(A.Dummy <long>(), succeededEventType, failedEventType);
return(result);
});
}
/// <summary>
/// Initializes a new instance of the <see cref="AccountingTimeDummyFactory"/> class.
/// </summary>
public AccountingTimeDummyFactory()
{
// ------------------------------------------------------------------------------------
// --------------------------- accounting period system ------------------------------
// ------------------------------------------------------------------------------------
AutoFixtureBackedDummyFactory.ConstrainDummyToExclude(FiftyTwoFiftyThreeWeekMethodology.Unknown);
AutoFixtureBackedDummyFactory.UseRandomConcreteSubclassForDummy <AccountingPeriodSystem>();
AutoFixtureBackedDummyFactory.AddDummyCreator(
() =>
{
var result = new FiscalYearAccountingPeriodSystem(A.Dummy <MonthOfYear>().ThatIsNot(MonthOfYear.December));
return(result);
});
// ------------------------------------------------------------------------------------
// ------------------------------------- time ----------------------------------------
// ------------------------------------------------------------------------------------
AutoFixtureBackedDummyFactory.ConstrainDummyToExclude(DayOfMonth.Invalid);
AutoFixtureBackedDummyFactory.ConstrainDummyToExclude(MonthNumber.Invalid);
AutoFixtureBackedDummyFactory.ConstrainDummyToExclude(MonthOfYear.Invalid);
AutoFixtureBackedDummyFactory.ConstrainDummyToExclude(QuarterNumber.Invalid);
AutoFixtureBackedDummyFactory.UseRandomConcreteSubclassForDummy <UnitOfTime>();
AutoFixtureBackedDummyFactory.UseRandomConcreteSubclassForDummy <CalendarUnitOfTime>();
AutoFixtureBackedDummyFactory.UseRandomConcreteSubclassForDummy <FiscalUnitOfTime>();
AutoFixtureBackedDummyFactory.UseRandomConcreteSubclassForDummy <GenericUnitOfTime>();
AutoFixtureBackedDummyFactory.UseRandomInterfaceImplementationForDummy <IHaveAMonth>();
AutoFixtureBackedDummyFactory.UseRandomInterfaceImplementationForDummy <IHaveAQuarter>();
AutoFixtureBackedDummyFactory.UseRandomInterfaceImplementationForDummy <IHaveAYear>();
AutoFixtureBackedDummyFactory.UseRandomInterfaceImplementationForDummy <IAmBoundedTime>();
AutoFixtureBackedDummyFactory.UseRandomInterfaceImplementationForDummy <IAmUnboundedTime>();
AutoFixtureBackedDummyFactory.AddDummyCreator(
() =>
{
var year = ThreadSafeRandom.Next(MinYear, MaxYear + 1);
var result = new GenericMonth(year, A.Dummy <MonthNumber>());
return(result);
});
AutoFixtureBackedDummyFactory.AddDummyCreator(
() =>
{
var year = ThreadSafeRandom.Next(MinYear, MaxYear + 1);
var result = new GenericQuarter(year, A.Dummy <QuarterNumber>());
return(result);
});
AutoFixtureBackedDummyFactory.AddDummyCreator(
() =>
{
var year = ThreadSafeRandom.Next(MinYear, MaxYear + 1);
var result = new GenericYear(year);
return(result);
});
AutoFixtureBackedDummyFactory.AddDummyCreator(
() =>
{
var year = ThreadSafeRandom.Next(MinYear, MaxYear + 1);
var result = new FiscalMonth(year, A.Dummy <MonthNumber>());
return(result);
});
AutoFixtureBackedDummyFactory.AddDummyCreator(
() =>
{
var year = ThreadSafeRandom.Next(MinYear, MaxYear + 1);
var result = new FiscalQuarter(year, A.Dummy <QuarterNumber>());
return(result);
});
AutoFixtureBackedDummyFactory.AddDummyCreator(
() =>
{
var year = ThreadSafeRandom.Next(MinYear, MaxYear + 1);
var result = new FiscalYear(year);
return(result);
});
AutoFixtureBackedDummyFactory.AddDummyCreator(
() =>
{
while (true)
{
try
{
var date = A.Dummy <DateTime>();
var year = ThreadSafeRandom.Next(MinYear, MaxYear + 1);
var result = new CalendarDay(year, (MonthOfYear)date.Month, (DayOfMonth)date.Day);
return(result);
}
catch (ArgumentException)
{
}
}
});
AutoFixtureBackedDummyFactory.AddDummyCreator(
() =>
{
var year = ThreadSafeRandom.Next(MinYear, MaxYear + 1);
var result = new CalendarMonth(year, A.Dummy <MonthOfYear>());
return(result);
});
AutoFixtureBackedDummyFactory.AddDummyCreator(
() =>
{
var year = ThreadSafeRandom.Next(MinYear, MaxYear + 1);
var result = new CalendarQuarter(year, A.Dummy <QuarterNumber>());
return(result);
});
AutoFixtureBackedDummyFactory.AddDummyCreator(
() =>
{
var year = ThreadSafeRandom.Next(MinYear, MaxYear + 1);
var result = new CalendarYear(year);
return(result);
});
// ------------------------------------------------------------------------------------
// ------------------------------ reporting period -----------------------------------
// ------------------------------------------------------------------------------------
AutoFixtureBackedDummyFactory.ConstrainDummyToExclude(ReportingPeriodComponent.Invalid);
AutoFixtureBackedDummyFactory.AddDummyCreator(
() =>
{
var potentialTypes = new[] { typeof(GenericReportingPeriod), typeof(FiscalReportingPeriod), typeof(CalendarReportingPeriod) };
var result = GetRandomReportingPeriodWrapper(potentialTypes).ReportingPeriod;
return(result);
});
// ------------------------------------------------------------------------------------
// ------------------------------------- unit ----------------------------------------
// ------------------------------------------------------------------------------------
AutoFixtureBackedDummyFactory.ConstrainDummyToExclude(UnitOfTimeKind.Invalid);
AutoFixtureBackedDummyFactory.ConstrainDummyToExclude(UnitOfTimeGranularity.Invalid);
AutoFixtureBackedDummyFactory.AddDummyCreator(
() =>
{
var unitOfTime = A.Dummy <UnitOfTime>().ThatIs(_ => !(_ is IAmUnboundedTime));
var result = new Unit(unitOfTime.UnitOfTimeKind, unitOfTime.UnitOfTimeGranularity);
return(result);
});
// ------------------------------------------------------------------------------------
// -------------------------- reporting period wrappers ------------------------------
// ------------------------------------------------------------------------------------
AutoFixtureBackedDummyFactory.AddDummyCreator(
() =>
{
var start = A.Dummy <GenericMonth>();
var end = A.Dummy <GenericMonth>();
var result = end >= start
? new GenericMonthReportingPeriod(start, end)
: new GenericMonthReportingPeriod(end, start);
return(result);
});
AutoFixtureBackedDummyFactory.AddDummyCreator(
() =>
{
var start = A.Dummy <GenericQuarter>();
var end = A.Dummy <GenericQuarter>();
var result = end >= start
? new GenericQuarterReportingPeriod(start, end)
: new GenericQuarterReportingPeriod(end, start);
return(result);
});
AutoFixtureBackedDummyFactory.AddDummyCreator(
() =>
{
var start = A.Dummy <GenericYear>();
var end = A.Dummy <GenericYear>();
var result = end >= start
? new GenericYearReportingPeriod(start, end)
: new GenericYearReportingPeriod(end, start);
return(result);
});
AutoFixtureBackedDummyFactory.AddDummyCreator(
() =>
{
var start = A.Dummy <FiscalMonth>();
var end = A.Dummy <FiscalMonth>();
var result = end >= start
? new FiscalMonthReportingPeriod(start, end)
: new FiscalMonthReportingPeriod(end, start);
return(result);
});
AutoFixtureBackedDummyFactory.AddDummyCreator(
() =>
{
var start = A.Dummy <FiscalQuarter>();
var end = A.Dummy <FiscalQuarter>();
var result = end >= start
? new FiscalQuarterReportingPeriod(start, end)
: new FiscalQuarterReportingPeriod(end, start);
return(result);
});
AutoFixtureBackedDummyFactory.AddDummyCreator(
() =>
{
var start = A.Dummy <FiscalYear>();
var end = A.Dummy <FiscalYear>();
var result = end >= start
? new FiscalYearReportingPeriod(start, end)
: new FiscalYearReportingPeriod(end, start);
return(result);
});
AutoFixtureBackedDummyFactory.AddDummyCreator(
() =>
{
var start = A.Dummy <CalendarDay>();
var end = A.Dummy <CalendarDay>();
var result = end >= start
? new CalendarDayReportingPeriod(start, end)
: new CalendarDayReportingPeriod(end, start);
return(result);
});
AutoFixtureBackedDummyFactory.AddDummyCreator(
() =>
{
var start = A.Dummy <CalendarMonth>();
var end = A.Dummy <CalendarMonth>();
var result = end >= start
? new CalendarMonthReportingPeriod(start, end)
: new CalendarMonthReportingPeriod(end, start);
return(result);
});
AutoFixtureBackedDummyFactory.AddDummyCreator(
() =>
{
var start = A.Dummy <CalendarQuarter>();
var end = A.Dummy <CalendarQuarter>();
var result = end >= start
? new CalendarQuarterReportingPeriod(start, end)
: new CalendarQuarterReportingPeriod(end, start);
return(result);
});
AutoFixtureBackedDummyFactory.AddDummyCreator(
() =>
{
var start = A.Dummy <CalendarYear>();
var end = A.Dummy <CalendarYear>();
var result = end >= start
? new CalendarYearReportingPeriod(start, end)
: new CalendarYearReportingPeriod(end, start);
return(result);
});
AutoFixtureBackedDummyFactory.AddDummyCreator(
() =>
{
var potentialTypes = new[] { typeof(BoundedGenericReportingPeriod), typeof(BoundedFiscalReportingPeriod), typeof(BoundedCalendarReportingPeriod) };
var reportingPeriod = GetRandomReportingPeriodWrapper(potentialTypes).ReportingPeriod;
var result = new BoundedReportingPeriod(reportingPeriod.Start, reportingPeriod.End);
return(result);
});
AutoFixtureBackedDummyFactory.AddDummyCreator(
() =>
{
var potentialTypes = new[] { typeof(GenericMonthReportingPeriod), typeof(GenericQuarterReportingPeriod), typeof(GenericYearReportingPeriod) };
var reportingPeriod = GetRandomReportingPeriodWrapper(potentialTypes).ReportingPeriod;
var result = new BoundedGenericReportingPeriod((GenericUnitOfTime)reportingPeriod.Start, (GenericUnitOfTime)reportingPeriod.End);
return(result);
});
AutoFixtureBackedDummyFactory.AddDummyCreator(
() =>
{
var potentialTypes = new[] { typeof(FiscalMonthReportingPeriod), typeof(FiscalQuarterReportingPeriod), typeof(FiscalYearReportingPeriod) };
var reportingPeriod = GetRandomReportingPeriodWrapper(potentialTypes).ReportingPeriod;
var result = new BoundedFiscalReportingPeriod((FiscalUnitOfTime)reportingPeriod.Start, (FiscalUnitOfTime)reportingPeriod.End);
return(result);
});
AutoFixtureBackedDummyFactory.AddDummyCreator(
() =>
{
var potentialTypes = new[] { typeof(CalendarDayReportingPeriod), typeof(CalendarMonthReportingPeriod), typeof(CalendarQuarterReportingPeriod), typeof(CalendarYearReportingPeriod) };
var reportingPeriod = GetRandomReportingPeriodWrapper(potentialTypes).ReportingPeriod;
var result = new BoundedCalendarReportingPeriod((CalendarUnitOfTime)reportingPeriod.Start, (CalendarUnitOfTime)reportingPeriod.End);
return(result);
});
AutoFixtureBackedDummyFactory.AddDummyCreator(
() =>
{
var boundedReportingPeriod = A.Dummy <BoundedGenericReportingPeriod>().ReportingPeriod;
var result = ThreadSafeRandom.Next(0, 2) == 0
? new SemiBoundedGenericReportingPeriod((GenericUnitOfTime)boundedReportingPeriod.Start, new GenericUnbounded())
: new SemiBoundedGenericReportingPeriod(new GenericUnbounded(), (GenericUnitOfTime)boundedReportingPeriod.End);
return(result);
});
AutoFixtureBackedDummyFactory.AddDummyCreator(
() =>
{
var boundedReportingPeriod = A.Dummy <BoundedFiscalReportingPeriod>().ReportingPeriod;
var result = ThreadSafeRandom.Next(0, 2) == 0
? new SemiBoundedFiscalReportingPeriod((FiscalUnitOfTime)boundedReportingPeriod.Start, new FiscalUnbounded())
: new SemiBoundedFiscalReportingPeriod(new FiscalUnbounded(), (FiscalUnitOfTime)boundedReportingPeriod.End);
return(result);
});
AutoFixtureBackedDummyFactory.AddDummyCreator(
() =>
{
var boundedReportingPeriod = A.Dummy <BoundedCalendarReportingPeriod>().ReportingPeriod;
var result = ThreadSafeRandom.Next(0, 2) == 0
? new SemiBoundedCalendarReportingPeriod((CalendarUnitOfTime)boundedReportingPeriod.Start, new CalendarUnbounded())
: new SemiBoundedCalendarReportingPeriod(new CalendarUnbounded(), (CalendarUnitOfTime)boundedReportingPeriod.End);
return(result);
});
AutoFixtureBackedDummyFactory.AddDummyCreator(
() =>
{
var potentialTypes = new[] { typeof(GenericUnboundedReportingPeriod), typeof(SemiBoundedGenericReportingPeriod), typeof(BoundedGenericReportingPeriod) };
var reportingPeriod = GetRandomReportingPeriodWrapper(potentialTypes).ReportingPeriod;
var result = new GenericReportingPeriod((GenericUnitOfTime)reportingPeriod.Start, (GenericUnitOfTime)reportingPeriod.End);
return(result);
});
AutoFixtureBackedDummyFactory.AddDummyCreator(
() =>
{
var potentialTypes = new[] { typeof(FiscalUnboundedReportingPeriod), typeof(SemiBoundedFiscalReportingPeriod), typeof(BoundedFiscalReportingPeriod) };
var reportingPeriod = GetRandomReportingPeriodWrapper(potentialTypes).ReportingPeriod;
var result = new FiscalReportingPeriod((FiscalUnitOfTime)reportingPeriod.Start, (FiscalUnitOfTime)reportingPeriod.End);
return(result);
});
AutoFixtureBackedDummyFactory.AddDummyCreator(
() =>
{
var potentialTypes = new[] { typeof(CalendarUnboundedReportingPeriod), typeof(SemiBoundedCalendarReportingPeriod), typeof(BoundedCalendarReportingPeriod) };
var reportingPeriod = GetRandomReportingPeriodWrapper(potentialTypes).ReportingPeriod;
var result = new CalendarReportingPeriod((CalendarUnitOfTime)reportingPeriod.Start, (CalendarUnitOfTime)reportingPeriod.End);
return(result);
});
// ------------------------------------------------------------------------------------
// ------------------------------------ cutoff ---------------------------------------
// ------------------------------------------------------------------------------------
AutoFixtureBackedDummyFactory.AddDummyCreator(
() =>
{
var result = new RelativeCutoff(A.Dummy <Duration>(), A.Dummy <ReportingPeriodComponent>().ThatIsIn(new[] { ReportingPeriodComponent.Start, ReportingPeriodComponent.End }));
return(result);
});
// ------------------------------------------------------------------------------------
// ---------------------------------- timeseries -------------------------------------
// ------------------------------------------------------------------------------------
AutoFixtureBackedDummyFactory.AddDummyCreator(
() =>
{
var result = (IDatapoint)A.Dummy <Datapoint <Version> >();
return(result);
});
AutoFixtureBackedDummyFactory.AddDummyCreator(
() =>
{
var result = (ITimeseries)A.Dummy <Timeseries <Version> >();
return(result);
});
AutoFixtureBackedDummyFactory.AddDummyCreator(
() =>
{
var result = GetDummyTimeseries <Version>();
return(result);
});
}
