Esempio n. 1
0
        public async Task TableRead_ManyRows_Succeeds()
        {
            var monitor1 = new TestScaleMonitor1();
            var monitors = new IScaleMonitor[] { monitor1 };

            var metricsTable = _repository.GetMetricsTable();
            await _repository.CreateIfNotExistsAsync(metricsTable);

            TableBatchOperation batch = new TableBatchOperation();

            int numRows = 500;

            for (int i = 0; i < numRows; i++)
            {
                var sample = new TestScaleMetrics1 {
                    Count = i
                };
                await Task.Delay(5);

                batch.Add(TableStorageScaleMetricsRepository.CreateMetricsInsertOperation(sample, TestHostId, monitor1.Descriptor));

                if (batch.Count % 100 == 0)
                {
                    await metricsTable.ExecuteBatchAsync(batch);

                    batch = new TableBatchOperation();
                }
            }
            if (batch.Count > 0)
            {
                await metricsTable.ExecuteBatchAsync(batch);
            }

            var results = await _repository.ReadMetricsAsync(monitors);

            Assert.Equal(1, results.Count);
            Assert.Equal(numRows, results[monitor1].Count);

            // verify results are returned in the order they were inserted (ascending
            // time order) and the timestamps are monotonically increasing
            var metrics = results[monitor1].ToArray();

            for (int i = 0; i < numRows - 1; i++)
            {
                for (int j = i + 1; j < numRows; j++)
                {
                    var m1 = (TestScaleMetrics1)metrics[i];
                    var m2 = (TestScaleMetrics1)metrics[j];
                    Assert.True(m1.Count < m2.Count);
                    Assert.True(metrics[i].Timestamp < metrics[j].Timestamp);
                }
            }
        }
Esempio n. 2
0
        public async Task ReadMetricsAsync_FiltersExpiredMetrics()
        {
            var monitor1 = new TestScaleMonitor1();
            var monitors = new IScaleMonitor[] { monitor1 };

            // add a bunch of expired samples
            var batch = new TableBatchOperation();

            for (int i = 5; i > 0; i--)
            {
                var metrics = new TestScaleMetrics1
                {
                    Count = i
                };
                var now = DateTime.UtcNow - _scaleOptions.ScaleMetricsMaxAge - TimeSpan.FromMinutes(i);
                await _repository.AccumulateMetricsBatchAsync(batch, monitor1, new ScaleMetrics[] { metrics }, now);
            }

            // add a few samples that aren't expired
            for (int i = 3; i > 0; i--)
            {
                var metrics = new TestScaleMetrics1
                {
                    Count = 77
                };
                var now = DateTime.UtcNow - TimeSpan.FromSeconds(i);
                await _repository.AccumulateMetricsBatchAsync(batch, monitor1, new ScaleMetrics[] { metrics }, now);
            }

            await _repository.ExecuteBatchSafeAsync(batch);

            var result = await _repository.ReadMetricsAsync(monitors);

            var resultMetrics = result[monitor1].Cast <TestScaleMetrics1>().ToArray();

            Assert.Equal(3, resultMetrics.Length);
            Assert.All(resultMetrics, p => Assert.Equal(77, p.Count));
        }