private static void AssertCompareResult(SampleHistory result, SampleHistory expectedResult)
 {
     Assert.That(result.ServerId, Is.EqualTo(expectedResult.ServerId));
     Assert.That(result.IsActiveArrivalRateSample, Is.EqualTo(expectedResult.IsActiveArrivalRateSample));
     Assert.That(result.IsActiveConcurrencySample, Is.EqualTo(expectedResult.IsActiveConcurrencySample));
     Assert.That(result.HourId, Is.EqualTo(expectedResult.HourId));
 }
Example #2
0
 public SampleTableHistoryViewModel()
 {
     AnalyzePer  = new AnalyzePerson();
     ArgumentHis = new ArgumentValueHistory();
     sampleReg   = new SampleRegisterTable();
     sampleHis   = new SampleHistory();
 }
Example #3
0
        public async Task AddToCurrentSampleAsync(SampleHistory sampleHistory)
        {
            using (var connection = this.connectionFactory.GetEddsPerformanceConnection())
            {
                var recordsUpdated = await connection.ExecuteAsync(Resources.SampleHistory_Update, sampleHistory);

                if (recordsUpdated == 0)
                {
                    await connection.ExecuteAsync(Resources.SampleHistory_AddCurrentSample, sampleHistory);
                }
            }
        }
        public async Task AddToCurrentSampleAsync(bool isActiveArrivalRateSample, bool isActiveConcurrencySample)
        {
            // Arrange
            await this.sampleHistoryRepository.ResetCurrentSampleAsync(serverId);             // Reset so our data is consistent

            var sampleHistory = new SampleHistory
            {
                ServerId = serverId,
                HourId   = startSampleHistories[0].HourId,
                IsActiveArrivalRateSample = isActiveArrivalRateSample,
                IsActiveConcurrencySample = isActiveConcurrencySample
            };

            // Act
            await this.sampleHistoryRepository.AddToCurrentSampleAsync(sampleHistory);

            // Assert
            var resultList = await this.sampleHistoryRepository.ReadCurrentArrivalRateSampleAsync(serverId);

            if (isActiveArrivalRateSample)
            {
                Assert.That(resultList, Is.Not.Empty);
                AssertCompareResult(resultList.First(), sampleHistory);
            }
            else
            {
                Assert.That(resultList, Is.Empty);
            }

            resultList = await this.sampleHistoryRepository.ReadCurrentConcurrencySampleAsync(serverId);

            if (isActiveConcurrencySample)
            {
                Assert.That(resultList, Is.Not.Empty);
                AssertCompareResult(resultList.First(), sampleHistory);
            }
            else
            {
                Assert.That(resultList, Is.Empty);
            }
        }