public async Task CanPostEventAsync()
{
var ev = new RandomEventGenerator().GeneratePersistent(false);
if (String.IsNullOrEmpty(ev.Message))
{
ev.Message = "Generated message.";
}
await SendTokenRequest(TestConstants.ApiKey, r => r
.Post()
.AppendPath("events")
.Content(ev)
.StatusCodeShouldBeAccepted()
);
var stats = await _eventQueue.GetQueueStatsAsync();
Assert.Equal(1, stats.Enqueued);
Assert.Equal(0, stats.Completed);
var processEventsJob = GetService <EventPostsJob>();
await processEventsJob.RunAsync();
await _configuration.Client.RefreshAsync(Indices.All);
stats = await _eventQueue.GetQueueStatsAsync();
Assert.Equal(1, stats.Completed);
var actual = await _eventRepository.GetAllAsync();
Assert.Single(actual.Documents);
Assert.Equal(ev.Message, actual.Documents.Single().Message);
}
public async Task CanPostManyEventsAsync()
{
const int batchSize = 250;
const int batchCount = 10;
await Run.InParallelAsync(batchCount, async i => {
_eventController.Request = CreateRequestMessage(new ClaimsPrincipal(GetClientToken().ToIdentity()), true, false);
var events = new RandomEventGenerator().Generate(batchSize);
var compressedEvents = await Encoding.UTF8.GetBytes(JsonConvert.SerializeObject(events)).CompressAsync();
var actionResult = await _eventController.PostAsync(compressedEvents, version: 2, userAgent: "exceptionless/2.0.0.0");
Assert.IsType <StatusCodeResult>(actionResult);
});
await _configuration.Client.RefreshAsync(Indices.All);
Assert.Equal(batchCount, (await _eventQueue.GetQueueStatsAsync()).Enqueued);
Assert.Equal(0, (await _eventQueue.GetQueueStatsAsync()).Completed);
var processEventsJob = GetService <EventPostsJob>();
var sw = Stopwatch.StartNew();
await processEventsJob.RunUntilEmptyAsync();
sw.Stop();
_logger.Info(sw.Elapsed.ToString());
await _configuration.Client.RefreshAsync(Indices.All);
var stats = await _eventQueue.GetQueueStatsAsync();
Assert.Equal(batchCount, stats.Completed);
var minimum = batchSize * batchCount;
Assert.InRange(await EventCountAsync(), minimum, minimum * 2);
}
public override bool ConfirmEventQueued(Child child)
{
if (RandomEventGenerator.IsChildTrafficked(child))
{
GameObject.Find(EventDialogScript.EventDialogName).GetComponent <EventDialogScript>().QueueEvent(new ChildTraffickedEventScript(child));
return(false);
}
return(base.ConfirmEventQueued(child));
}
public void GetRandomEvent_NoParam_GetRandomEvent()
{
//ARRANGE
//ACT
var testEvent = RandomEventGenerator.GetRandomEvent();
//ASSERT
Assert.IsNotNull(testEvent);
Assert.IsFalse(string.IsNullOrEmpty(testEvent.EventName));
}
public async Task CanPostManyEventsAsync()
{
await ResetAsync();
const int batchSize = 250;
const int batchCount = 10;
try {
var countdown = new AsyncCountdownEvent(batchCount);
var messageSubscriber = IoC.GetInstance <IMessageSubscriber>();
messageSubscriber.Subscribe <ExtendedEntityChanged>(ch => {
if (ch.ChangeType != ChangeType.Added || ch.Type != typeof(PersistentEvent).Name)
{
return;
}
if (countdown.CurrentCount >= batchCount)
{
throw new ApplicationException("Too many change notifications.");
}
countdown.Signal();
});
await Run.InParallelAsync(batchCount, async i => {
_eventController.Request = CreateRequestMessage(new ClaimsPrincipal(new User {
EmailAddress = TestConstants.UserEmail, Id = TestConstants.UserId, OrganizationIds = new[] { TestConstants.OrganizationId }, Roles = new[] { AuthorizationRoles.Client }
}.ToIdentity(TestConstants.ProjectId)), true, false);
var events = new RandomEventGenerator().Generate(batchSize);
var compressedEvents = await Encoding.UTF8.GetBytes(JsonConvert.SerializeObject(events)).CompressAsync();
var actionResult = await _eventController.PostAsync(compressedEvents, version: 2, userAgent: "exceptionless/2.0.0.0");
Assert.IsType <StatusCodeResult>(actionResult);
});
await _client.RefreshAsync();
Assert.Equal(batchCount, (await _eventQueue.GetQueueStatsAsync()).Enqueued);
Assert.Equal(0, (await _eventQueue.GetQueueStatsAsync()).Completed);
var processEventsJob = IoC.GetInstance <EventPostsJob>();
var sw = Stopwatch.StartNew();
await processEventsJob.RunUntilEmptyAsync();
sw.Stop();
Trace.WriteLine(sw.Elapsed);
await _client.RefreshAsync();
Assert.Equal(batchCount, (await _eventQueue.GetQueueStatsAsync()).Completed);
var minimum = batchSize * batchCount;
Assert.InRange(await EventCountAsync(), minimum, minimum * 2);
} finally {
await _eventQueue.DeleteQueueAsync();
}
}
public override bool ConfirmEventQueued(Child selectedChild)
{
if (RandomEventGenerator.IsChildTrafficked(selectedChild))
{
GameObject.Find(EventDialogScript.EventDialogName).GetComponent <EventDialogScript>().QueueEvent(new ChildTraffickedEventScript(selectedChild));
return(false);
}
// Decide when child is locked in whether they will be paid or not
// This is so we can know whether to create the child going home
ChildCanLeaveAtEndOfYearRecords.Enqueue(UnityEngine.Random.Range(0.0f, 1.0f) < 0.9f);
return(true);
}
public void CanPostManyEvents()
{
_eventQueue.DeleteQueue();
RemoveAllEvents();
const int batchSize = 250;
const int batchCount = 10;
try {
var countdown = new CountDownLatch(10);
var messageSubscriber = IoC.GetInstance <IMessageSubscriber>();
messageSubscriber.Subscribe <EntityChanged>(ch => {
if (ch.ChangeType != ChangeType.Added || ch.Type != typeof(PersistentEvent).Name)
{
return;
}
if (countdown.Remaining <= 0)
{
throw new ApplicationException("Too many change notifications.");
}
countdown.Signal();
});
Parallel.For(0, batchCount, i => {
_eventController.Request = CreateRequestMessage(new ClaimsPrincipal(IdentityUtils.CreateUserIdentity(TestConstants.UserEmail, TestConstants.UserId, new[] { TestConstants.OrganizationId }, new[] { AuthorizationRoles.Client }, TestConstants.ProjectId)), true, false);
var events = new RandomEventGenerator().Generate(batchSize);
var compressedEvents = Encoding.UTF8.GetBytes(new DefaultJsonSerializer().Serialize(events)).Compress();
var actionResult = _eventController.Post(compressedEvents, version: 2, userAgent: "exceptionless/2.0.0.0");
Assert.IsType <StatusCodeResult>(actionResult);
});
Assert.Equal(batchCount, _eventQueue.GetQueueCount());
var sw = new Stopwatch();
var processEventsJob = IoC.GetInstance <EventPostsJob>();
sw.Start();
processEventsJob.RunUntilEmpty();
sw.Stop();
Trace.WriteLine(sw.Elapsed);
Assert.Equal(0, _eventQueue.GetQueueCount());
Assert.Equal(batchSize * batchCount, EventCount());
bool success = countdown.Wait(5000);
Assert.True(success);
} finally {
_eventQueue.DeleteQueue();
}
}
public Person GenerateInNhanes2003Format(
IEnumerable <int> availableEvents, int length,
double degreeOfRandomness, int nonRandomEvent = 0)
{
var person = new Person(null);
person.Id = startId;
startId++;
IRandomEventGenerator rndEventGenerator = new RandomEventGenerator();
List <int> randomEvents = rndEventGenerator
.GenerateRandomEventsWithDegreeOfRandomess(availableEvents, length,
degreeOfRandomness, nonRandomEvent).ToList();
var records = new List <NhanesRecord>();
for (int i = 0; i < length; i++)
{
var record = new NhanesRecord();
int subjectId = (int)person.Id;
byte reliabilityFlag = 1; //reliable
byte calibrationFlag = 1; //calibrated
byte dayOfWeek = 0; //don't set this for generated data
int sequenceId = 0; //don't set this for generated data
byte hour = 0; //don't set this for generated data
byte minute = 0; //don't set this for generated data
int deviceIntensity = 0; //don't set this for generated data
var intencityCode = (IntensityCodes)Enum.Parse(typeof(IntensityCodes),
randomEvents[i].ToString());
record.SetValues(subjectId: subjectId,
reliabilityFlag: reliabilityFlag,
calibrationFlag: calibrationFlag,
dayOfWeek: dayOfWeek,
sequenceId: sequenceId,
hour: hour,
minute: minute,
deviceIntensity: deviceIntensity,
stepCount: null,
intensityCode: intencityCode);
records.Add(record);
}
person.NhanesRecords = records;
return(person);
}
public void GetRandomEvent_100Iterations_Get100DifferentRandomEvent()
{
//ARRANGE
List <Action> actions = new List <Action>();
//ACT
for (int i = 0; i < 100; i++)
{
actions.Add(RandomEventGenerator.GetRandomEvent());
}
//ASSERT
Assert.IsNotNull(actions);
Assert.AreEqual(100, actions.Count);
var events = actions.Select(a => a.EventName).Distinct().ToList();
Assert.IsTrue(events.Count > 7);
Assert.IsTrue(events.Count <= 10);
}
public async Task CanPostManyEventsAsync()
{
await ResetAsync();
const int batchSize = 250;
const int batchCount = 10;
try {
await Run.InParallelAsync(batchCount, async i => {
_eventController.Request = CreateRequestMessage(new ClaimsPrincipal(new User {
EmailAddress = TestConstants.UserEmail, Id = TestConstants.UserId, OrganizationIds = new[] { TestConstants.OrganizationId }, Roles = new[] { AuthorizationRoles.Client }
}.ToIdentity(TestConstants.ProjectId)), true, false);
var events = new RandomEventGenerator().Generate(batchSize);
var compressedEvents = await Encoding.UTF8.GetBytes(JsonConvert.SerializeObject(events)).CompressAsync();
var actionResult = await _eventController.PostAsync(compressedEvents, version: 2, userAgent: "exceptionless/2.0.0.0");
Assert.IsType <StatusCodeResult>(actionResult);
});
await _client.RefreshAsync();
Assert.Equal(batchCount, (await _eventQueue.GetQueueStatsAsync()).Enqueued);
Assert.Equal(0, (await _eventQueue.GetQueueStatsAsync()).Completed);
var processEventsJob = IoC.GetInstance <EventPostsJob>();
var sw = Stopwatch.StartNew();
await processEventsJob.RunUntilEmptyAsync();
sw.Stop();
Trace.WriteLine(sw.Elapsed);
await _client.RefreshAsync();
var stats = await _eventQueue.GetQueueStatsAsync();
Assert.Equal(batchCount, stats.Completed);
var minimum = batchSize * batchCount;
Assert.InRange(await EventCountAsync(), minimum, minimum * 2);
} finally {
await _eventQueue.DeleteQueueAsync();
}
}
public async Task CanPostManyEventsAsync()
{
const int batchSize = 50;
const int batchCount = 10;
await Run.InParallelAsync(batchCount, async i => {
var events = new RandomEventGenerator().Generate(batchSize, false);
await SendRequestAsync(r => r
.Post()
.AsTestOrganizationClientUser()
.AppendPath("events")
.Content(events)
.StatusCodeShouldBeAccepted()
);
});
await RefreshDataAsync();
var stats = await _eventQueue.GetQueueStatsAsync();
Assert.Equal(batchCount, stats.Enqueued);
Assert.Equal(0, stats.Completed);
var processEventsJob = GetService <EventPostsJob>();
var sw = Stopwatch.StartNew();
await processEventsJob.RunUntilEmptyAsync();
sw.Stop();
_logger.LogInformation("{Duration:g}", sw.Elapsed);
await RefreshDataAsync();
stats = await _eventQueue.GetQueueStatsAsync();
Assert.Equal(batchCount, stats.Completed);
Assert.Equal(batchSize * batchCount, await _eventRepository.CountAsync());
}
private void CheckRandomEventOccurance()
{
var @event = RandomEventGenerator.Generate(Game.Gang);
if ([email protected])
{
return;
}
Console.WriteLine("Nastąpiło zdarzenie losowe.");
Console.WriteLine(@event.RandomEvent.Name);
if (@event.RandomEvent.AffectsMembers)
{
var numberOfCasualities = RandomGenerator.GetForRange(1, 4);
if (numberOfCasualities >= Game.Gang.Members.Count)
{
Console.WriteLine("W wyniku zdarzenia losowego straciliśmy wszystkich członków gangu");
Game.Gang.RemoveAllMembers();
}
else
{
Console.WriteLine($"W wyniku zdarzenia straciliśmy następującą ilość członków gangu: {numberOfCasualities}");
while (numberOfCasualities > 0)
{
var lostMember = Game.Gang.Members[RandomGenerator.GetForRange(0, Game.Gang.Members.Count)];
Game.Gang.RemoveMember(lostMember);
numberOfCasualities--;
}
}
}
if (@event.RandomEvent.AffectsInfrastructure)
{
var destroyedProperty = Game.Gang.Properties[RandomGenerator.GetForRange(0, Game.Gang.Properties.Count)];
Console.WriteLine($"W wyniku zdarzenia losowego straciliśmy nieruchomość: {destroyedProperty.Name}.");
Game.Gang.RemoveProperty(destroyedProperty);
}
}
public void activateEvent(EventObject eo)
{
currentEvent = eo;
if (eo.randomBuy)
{
activateEvent(RandomEventGenerator.makeBuy());
}
if (eo.randomSell)
{
activateEvent(RandomEventGenerator.makeSell());
}
if (eo.randomQuest)
{
activateEvent(RandomEventGenerator.makeQuest());
}
foreach (ResourceAmount r in eo.effects)
{
ResourceStorage.Instance.addResource(r.resourceName, r.amount);
}
if (eo.assignedQuest != null)
{
try {
QuestManager.Instance.assignQuest(eo.assignedQuest);
}
catch (TooManyQuestsException) {
activateEvent(eo.onTooManyQuests);
}
}
if (eo.setUpNewEvent != null && eo.setUpNewEvent.eventObject != null)
{
addTurnEvent(eo.setUpNewEvent);
}
List <EventObject.EventGroup> availableEvents = new List <EventObject.EventGroup>();
if (eo.redirectEvents != null)
{
foreach (EventObject.EventGroup e in eo.redirectEvents)
{
if (e.eventObject.matchesPrerequisites())
{
availableEvents.Add(e);
}
}
}
if (availableEvents.Count > 0)
{
EventObject newEO = getRandomEventFromProbabilities(availableEvents.ToArray());
if (newEO != null)
{
activateEvent(newEO);
}
}
UIManager.Instance.updateAll();
}
static void Main()
{
RandomEventGenerator reg = new RandomEventGenerator();
reg.Generate();
}
static void Main()
{
RandomEventGenerator reg = new RandomEventGenerator();
reg.Generate();
}
