public void FailToObtainAzureInstanceMetadataFieldsAltogether()
        {
            HeartbeatProviderMock            hbeatMock = new HeartbeatProviderMock();
            AzureInstanceMetadataRequestMock azureInstanceRequestorMock = new AzureInstanceMetadataRequestMock(
                getComputeMetadata: () =>
            {
                try
                {
                    throw new System.Exception("Failure");
                }
                catch
                {
                }

                return(null);
            });
            var azureIMSFields = new AzureComputeMetadataHeartbeatPropertyProvider(azureInstanceRequestorMock);
            var defaultFields  = azureIMSFields.ExpectedAzureImsFields;

            // not adding the fields we're looking for, simulation of the Azure Instance Metadata service not being present...
            var taskWaiter = azureIMSFields.SetDefaultPayloadAsync(hbeatMock).ConfigureAwait(false);

            Assert.False(taskWaiter.GetAwaiter().GetResult()); // nop await for tests

            foreach (string fieldName in defaultFields)
            {
                string heartbeatFieldName = string.Concat(AzureComputeMetadataHeartbeatPropertyProvider.HeartbeatPropertyPrefix, fieldName);
                Assert.False(hbeatMock.HbeatProps.ContainsKey(heartbeatFieldName));
            }
        }
        public void SentHeartbeatContainsExpectedDefaultFields()
        {
            using (var hbeatMock = new HeartbeatProviderMock())
            {
                var baseHbeatProps = new BaseDefaultHeartbeatPropertyProvider().DefaultFields;

                var taskWaiter = HeartbeatDefaultPayload.PopulateDefaultPayload(new string[] { }, new string[] { }, hbeatMock).ConfigureAwait(false);
                Assert.IsTrue(taskWaiter.GetAwaiter().GetResult()); // no await for tests

                foreach (string fieldName in baseHbeatProps)
                {
                    Assert.IsTrue(hbeatMock.HeartbeatProperties.ContainsKey(fieldName));
                }
            }
        }
        public void DefaultHeartbeatPropertyProviderSendsNoFieldWhenDisabled()
        {
            var mockHbeat = new HeartbeatProviderMock();
            IHeartbeatDefaultPayloadProvider baseDefaultProvider = HeartbeatDefaultPayload.DefaultPayloadProviders.First();
            var hbeatPayload = HeartbeatDefaultPayload.PopulateDefaultPayload(new string[] { }, new string[] { baseDefaultProvider.Name }, mockHbeat);

            hbeatPayload.GetAwaiter().GetResult();

            // for each heartbeat property recorded into the heartbeat provider, none should be a registered keyword on
            // this base default heartbeat property provider.
            foreach (string payloadPropertyName in mockHbeat.HeartbeatProperties.Keys)
            {
                Assert.IsFalse(baseDefaultProvider.IsKeyword(payloadPropertyName));
            }
        }
        public void GetAzureInstanceMetadataFieldsAsExpected()
        {
            HeartbeatProviderMock            hbeatMock = new HeartbeatProviderMock();
            AzureInstanceMetadataRequestMock azureInstanceRequestorMock  = new AzureInstanceMetadataRequestMock();
            AzureComputeMetadataHeartbeatPropertyProvider azureIMSFields = new AzureComputeMetadataHeartbeatPropertyProvider(azureInstanceRequestorMock);

            var taskWaiter = azureIMSFields.SetDefaultPayloadAsync(hbeatMock).ConfigureAwait(false);

            Assert.True(taskWaiter.GetAwaiter().GetResult()); // no await for tests

            foreach (string fieldName in azureIMSFields.ExpectedAzureImsFields)
            {
                string expectedFieldName = string.Concat(AzureComputeMetadataHeartbeatPropertyProvider.HeartbeatPropertyPrefix, fieldName);
                Assert.True(hbeatMock.HbeatProps.ContainsKey(expectedFieldName));
                Assert.False(string.IsNullOrEmpty(hbeatMock.HbeatProps[expectedFieldName]));
            }
        }
        public void AzureInstanceMetadataObtainedSuccessfully()
        {
            AzureInstanceComputeMetadata expected = new AzureInstanceComputeMetadata()
            {
                Location             = "US-West",
                Name                 = "test-vm01",
                Offer                = "D9_USWest",
                OsType               = "Linux",
                PlatformFaultDomain  = "0",
                PlatformUpdateDomain = "0",
                Publisher            = "Microsoft",
                ResourceGroupName    = "test.resource-group_01",
                Sku            = "Windows_10",
                SubscriptionId = Guid.NewGuid().ToString(),
                Version        = "10.8a",
                VmId           = Guid.NewGuid().ToString(),
                VmSize         = "A8"
            };

            HeartbeatProviderMock            hbeatMock = new HeartbeatProviderMock();
            AzureInstanceMetadataRequestMock azureInstanceRequestorMock = new AzureInstanceMetadataRequestMock(
                getComputeMetadata: () =>
            {
                return(expected);
            });
            var azureIMSFields = new AzureComputeMetadataHeartbeatPropertyProvider(azureInstanceRequestorMock);
            var defaultFields  = azureIMSFields.ExpectedAzureImsFields;

            // not adding the fields we're looking for, simulation of the Azure Instance Metadata service not being present...
            var taskWaiter = azureIMSFields.SetDefaultPayloadAsync(hbeatMock).ConfigureAwait(false);

            Assert.True(taskWaiter.GetAwaiter().GetResult()); // nop await for tests

            foreach (string fieldName in defaultFields)
            {
                string heartbeatFieldName = string.Concat(AzureComputeMetadataHeartbeatPropertyProvider.HeartbeatPropertyPrefix, fieldName);
                Assert.True(hbeatMock.HbeatProps.ContainsKey(heartbeatFieldName));
                Assert.Equal(expected.GetValueForField(fieldName), hbeatMock.HbeatProps[heartbeatFieldName]);
            }
        }
        public void AzureImsResponseExcludesMalformedValues()
        {
            string testPath = "malformedValues";

            using (new AzureInstanceMetadataServiceMock(
                       AzureInstanceMetadataEndToEndTests.MockTestUri,
                       testPath,
                       (response) =>
            {
                response.StatusCode = (int)HttpStatusCode.OK;

                // make it a malicious-ish response...
                var malformedData = this.GetTestMetadata();
                malformedData.Name = "Not allowed for VM names";
                malformedData.ResourceGroupName = "Not allowed for resource group name";
                malformedData.SubscriptionId = "Definitely-not-a GUID up here";
                var malformedJsonStream = this.GetTestMetadataStream(malformedData);

                response.SetContentLength(malformedJsonStream.Length);
                response.ContentType = "application/json";
                response.SetContentEncoding(Encoding.UTF8);
                response.WriteStreamToBody(malformedJsonStream);
            }))
            {
                var azureIms = new AzureMetadataRequestor
                {
                    BaseAimsUri = string.Concat(AzureInstanceMetadataEndToEndTests.MockTestUri, testPath, "/")
                };

                var azureImsProps = new AzureComputeMetadataHeartbeatPropertyProvider(azureIms);
                var hbeatProvider = new HeartbeatProviderMock();
                var azureIMSData  = azureImsProps.SetDefaultPayloadAsync(hbeatProvider);
                azureIMSData.Wait();

                Assert.Empty(hbeatProvider.HbeatProps["azInst_name"]);
                Assert.Empty(hbeatProvider.HbeatProps["azInst_resourceGroupName"]);
                Assert.Empty(hbeatProvider.HbeatProps["azInst_subscriptionId"]);
            }
        }
 public void BeforeEachTestMethod()
 {
     this.testHeartbeatPropertyManager = new HeartbeatProviderMock();
     this.testAppServiceHbeatModule    = this.GetAppServiceHeartbeatModuleWithUniqueTestEnvVars(this.testHeartbeatPropertyManager);
     this.testEnvironmentVariables     = this.GetEnvVarsAssociatedToModule(this.testAppServiceHbeatModule);
 }
        private AppServicesHeartbeatTelemetryModule GetAppServiceHeartbeatModuleWithUniqueTestEnvVars(HeartbeatProviderMock heartbeatProvider)
        {
            var    appServicesHbeatModule = new AppServicesHeartbeatTelemetryModule(heartbeatProvider);
            string testSuffix             = Guid.NewGuid().ToString();

            for (int i = 0; i < appServicesHbeatModule.WebHeartbeatPropertyNameEnvVarMap.Length; ++i)
            {
                var kvp = appServicesHbeatModule.WebHeartbeatPropertyNameEnvVarMap[i];
                appServicesHbeatModule.WebHeartbeatPropertyNameEnvVarMap[i] = new KeyValuePair <string, string>(kvp.Key, string.Concat(kvp.Value, "_", testSuffix));
            }

            return(appServicesHbeatModule);
        }