public void SetUp()
{
mockLogger = Substitute.For <ILogger>();
mockOpenKitConfiguration = Substitute.For <IOpenKitConfiguration>();
mockOpenKitConfiguration.ApplicationId.Returns(string.Empty);
mockOpenKitConfiguration.ApplicationName.Returns(string.Empty);
mockOpenKitConfiguration.ApplicationVersion.Returns(string.Empty);
mockOpenKitConfiguration.DeviceId.Returns(DeviceId);
mockPrivacyConfiguration = Substitute.For <IPrivacyConfiguration>();
mockBeaconCache = Substitute.For <IBeaconCache>();
mockSessionIdProvider = Substitute.For <ISessionIdProvider>();
mockThreadIdProvider = Substitute.For <IThreadIdProvider>();
mockTimingProvider = Substitute.For <ITimingProvider>();
mockParent = Substitute.For <IOpenKitComposite>();
mockInput = Substitute.For <ISessionCreatorInput>();
mockInput.Logger.Returns(mockLogger);
mockInput.OpenKitConfiguration.Returns(mockOpenKitConfiguration);
mockInput.PrivacyConfiguration.Returns(mockPrivacyConfiguration);
mockInput.BeaconCache.Returns(mockBeaconCache);
mockInput.SessionIdProvider.Returns(mockSessionIdProvider);
mockInput.ThreadIdProvider.Returns(mockThreadIdProvider);
mockInput.TimingProvider.Returns(mockTimingProvider);
mockInput.CurrentServerId.Returns(ServerId);
}
public OpenKitInitializer(IOpenKitBuilder builder)
{
logger = builder.Logger;
privacyConfiguration = PrivacyConfiguration.From(builder);
openKitConfiguration = OpenKitConfiguration.From(builder);
timingProvider = new DefaultTimingProvider();
threadIdProvider = new DefaultThreadIdProvider();
sessionIdProvider = new DefaultSessionIdProvider();
beaconCache = new BeaconCache(logger);
beaconCacheEvictor = new BeaconCacheEvictor(logger, beaconCache, BeaconCacheConfiguration.From(builder),
timingProvider);
var httpClientConfig = HttpClientConfiguration.From(openKitConfiguration);
// shared thread suspender between BeaconSender and HttpClient. HttpClient will be woken up when
// BeaconSender shuts down
var beaconSenderThreadSuspender = new InterruptibleThreadSuspender();
beaconSender = new BeaconSender(
logger,
httpClientConfig,
new DefaultHttpClientProvider(logger, beaconSenderThreadSuspender),
timingProvider,
beaconSenderThreadSuspender);
var watchdogThreadSuspender = new InterruptibleThreadSuspender();
sessionWatchdog = new SessionWatchdog(
logger,
new SessionWatchdogContext(timingProvider, watchdogThreadSuspender));
}
public void SetUp()
{
mockLogger = Substitute.For <ILogger>();
mockLogger.IsInfoEnabled.Returns(true);
mockLogger.IsDebugEnabled.Returns(true);
mockPrivacyConfig = Substitute.For <IPrivacyConfiguration>();
mockPrivacyConfig.DataCollectionLevel.Returns(ConfigurationDefaults.DefaultDataCollectionLevel);
mockPrivacyConfig.CrashReportingLevel.Returns(ConfigurationDefaults.DefaultCrashReportingLevel);
mockOpenKitConfig = Substitute.For <IOpenKitConfiguration>();
mockOpenKitConfig.ApplicationId.Returns(AppId);
mockOpenKitConfig.DeviceId.Returns(DeviceId);
mockOpenKitConfig.ApplicationName.Returns(AppName);
mockOpenKitConfig.OperatingSystem.Returns(string.Empty);
mockOpenKitConfig.Manufacturer.Returns(string.Empty);
mockOpenKitConfig.ModelId.Returns(string.Empty);
mockTimingProvider = Substitute.For <ITimingProvider>();
mockThreadIdProvider = Substitute.For <IThreadIdProvider>();
mockSessionIdProvider = Substitute.For <ISessionIdProvider>();
mockBeaconCache = Substitute.For <IBeaconCache>();
mockBeaconSender = Substitute.For <IBeaconSender>();
mockBeaconCacheEvictor = Substitute.For <IBeaconCacheEvictor>();
mockSessionWatchdog = Substitute.For <ISessionWatchdog>();
}
/// <summary>
/// Creates a <see cref="IBeaconConfiguration"/> from the given <see cref="IOpenKitConfiguration"/> and
/// <see cref="IPrivacyConfiguration"/>.
/// </summary>
/// <param name="openKitConfiguration">OpenKit configuration.</param>
/// <param name="privacyConfiguration">privacy related settings.</param>
/// <param name="serverId">identifier of the server to communicate with.</param>
/// <returns></returns>
public static IBeaconConfiguration From(
IOpenKitConfiguration openKitConfiguration,
IPrivacyConfiguration privacyConfiguration,
int serverId)
{
if (openKitConfiguration == null || privacyConfiguration == null)
{
return(null);
}
return(new BeaconConfiguration(openKitConfiguration, privacyConfiguration, serverId));
}
private BeaconConfiguration(
IOpenKitConfiguration openKitConfiguration,
IPrivacyConfiguration privacyConfiguration,
int serverId)
{
OpenKitConfiguration = openKitConfiguration;
PrivacyConfiguration = privacyConfiguration;
HttpClientConfiguration = Configuration.HttpClientConfiguration.ModifyWith(openKitConfiguration)
.WithServerId(serverId)
.Build();
serverConfiguration = null;
}
public TestOpenKitBuilder()
{
logger = Substitute.For <ILogger>();
privacyConfig = Substitute.For <IPrivacyConfiguration>();
openKitConfig = Substitute.For <IOpenKitConfiguration>();
threadIdProvider = Substitute.For <IThreadIdProvider>();
timingProvider = Substitute.For <ITimingProvider>();
sessionIdProvider = Substitute.For <ISessionIdProvider>();
beaconCache = Substitute.For <IBeaconCache>();
beaconSender = Substitute.For <IBeaconSender>();
beaconCacheEvictor = Substitute.For <IBeaconCacheEvictor>();
sessionWatchdog = Substitute.For <ISessionWatchdog>();
}
internal SessionCreator(ISessionCreatorInput input, string clientIpAddress)
{
Logger = input.Logger;
openKitConfiguration = input.OpenKitConfiguration;
privacyConfiguration = input.PrivacyConfiguration;
BeaconCache = input.BeaconCache;
ThreadIdProvider = input.ThreadIdProvider;
TimingProvider = input.TimingProvider;
ClientIpAddress = clientIpAddress;
serverId = input.CurrentServerId;
continuousSessionIdProvider = input.SessionIdProvider;
continuousRandomNumberGenerator = new DefaultPrnGenerator();
InitializeFixedNumberProviders();
}
/// <summary>
/// Constructor for creating an OpenKit instance.
/// </summary>
/// <param name="initializer">provider to get all OpenKit related configuration parameters.</param>
internal OpenKit(IOpenKitInitializer initializer)
{
logger = initializer.Logger;
privacyConfiguration = initializer.PrivacyConfiguration;
openKitConfiguration = initializer.OpenKitConfiguration;
timingProvider = initializer.TimingProvider;
threadIdProvider = initializer.ThreadIdProvider;
sessionIdProvider = initializer.SessionIdProvider;
beaconCache = initializer.BeaconCache;
beaconCacheEvictor = initializer.BeaconCacheEvictor;
beaconSender = initializer.BeaconSender;
sessionWatchdog = initializer.SessionWatchdog;
LogOpenKitInstanceCreation(logger, openKitConfiguration);
}
public void SetUp()
{
mockOpenKitConfig = Substitute.For <IOpenKitConfiguration>();
mockPrivacyConfig = Substitute.For <IPrivacyConfiguration>();
}
internal TestOpenKitBuilder With(IPrivacyConfiguration config)
{
privacyConfig = config;
return(this);
}
