public void PushAndRedeployContinuousJobAsConsoleWorker()
{
RunScenario("PushAndRedeployContinuousJobAsConsoleWorker", appManager =>
{
using (TestRepository testRepository = Git.Clone("ConsoleWorker"))
{
///////// Part 1
TestTracer.Trace("I) Starting ConsoleWorker test, deploying the worker");
PushAndVerifyConsoleWorker(appManager, testRepository, new string[] { ExpectedVerificationFileContent });
///////// Part 2
TestTracer.Trace("II) Make sure redeploy works for console worker");
testRepository.Replace("ConsoleWorker\\Program.cs", ExpectedVerificationFileContent, ExpectedChangedFileContent);
Git.Commit(testRepository.PhysicalPath, "Made a small change");
PushAndVerifyConsoleWorker(appManager, testRepository, new string[] { ExpectedVerificationFileContent, ExpectedChangedFileContent }, expectedDeployments: 2);
}
});
}
public void CreateSameContinuousJobTwiceUpdatesJobBinaries()
{
RunScenario("CreateSameContinuousJobTwiceUpdatesJobBinaries", appManager =>
{
const string secondScriptName = "myrun.cmd";
const string jobName = "job1";
const string jobPath = JobsBinPath + "/continuous/" + jobName + "/";
string zippedJobBinaries = BuildZippedJobBinaries();
appManager.JobsManager.CreateContinuousJobAsync(jobName, zippedJobBinaries).Wait();
Assert.True(appManager.VfsManager.Exists(jobPath + "inner/run.cmd"));
Assert.False(appManager.VfsManager.Exists(jobPath + secondScriptName));
TestTracer.Trace("Second continuous job creation should replace current binaries");
appManager.JobsManager.CreateContinuousJobAsync(jobName, secondScriptName, "echo test test test test").Wait();
Assert.False(appManager.VfsManager.Exists(jobPath + "inner/run.cmd"));
Assert.True(appManager.VfsManager.Exists(jobPath + secondScriptName));
});
}
public void TestSendToTooManyRecipients()
{
hMailServer.Accounts accounts = _domain.Accounts;
SingletonProvider <TestSetup> .Instance.AddAccount(accounts, string.Format("*****@*****.**"), "test");
var sock = new TcpConnection();
sock.Connect(25);
sock.ReadUntil("\r\n");
string result;
sock.Send("EHLO test.com\r\n");
result = sock.ReadUntil("\r\n");
Assert.IsTrue(result.StartsWith("250"));
sock.Send("MAIL FROM: [email protected]\r\n");
result = sock.ReadUntil("\r\n");
Assert.IsTrue(result.StartsWith("250"));
const int recipientCount = 51000;
for (int i = 1; i <= recipientCount; i++)
{
string address = string.Format("test{0}@gmail.com", i);
sock.Send(string.Format("RCPT TO: <{0}>\r\n", address));
result = sock.ReadUntil("\r\n");
if (i <= 50000)
{
Assert.IsTrue(result.StartsWith("250"));
}
else
{
Assert.IsFalse(result.StartsWith("250"));
}
if (i % 100 == 0)
{
TestTracer.WriteTraceInfo("{0}/{1}", i, recipientCount);
}
}
}
private static async Task DeployZippedArtifact(ApplicationManager applicationManager,
RemotePushDeploymentManager deploymentManager,
TestFile[] files,
string type,
string path,
bool isAsync)
{
TestTracer.Trace("Deploying zip");
using (var zipStream = DeploymentTestHelper.CreateZipStream(files))
{
IList<KeyValuePair<string, string>> queryParams = GetOneDeployQueryParams(type, path, isAsync);
var response = await deploymentManager.PushDeployFromStream(zipStream, new ZipDeployMetadata(), queryParams);
response.EnsureSuccessStatusCode();
if (isAsync)
{
await DeploymentTestHelper.WaitForDeploymentCompletionAsync(applicationManager, deployer);
}
}
}
public void OnRequest_span_is_child_of_parent()
{
var tracer = new TestTracer();
var traceContext = new TraceContext();
var interceptor = GetInterceptor(tracer, traceContext);
var request = new HttpRequestMessage(HttpMethod.Get, new Uri("http://www.example.com/api/values"));
// Create parent span
var parentSpan = tracer.BuildSpan("parent").Start();
traceContext.Push(parentSpan);
// Call interceptor
interceptor.OnRequest(request);
var newSpan = (TestSpan)request.Properties[PropertySpan];
Assert.NotSame(parentSpan, newSpan);
Assert.Equal(References.ChildOf, newSpan.TypedContext.References[0].ReferenceType);
Assert.Same(parentSpan.Context, newSpan.TypedContext.References[0].ReferencedContext);
}
public async Task SiteExtensionV2AndV3FeedTests(string feedEndpoint)
{
TestTracer.Trace("Testing against feed: '{0}'", feedEndpoint);
const string appName = "SiteExtensionV2AndV3FeedTests";
const string testPackageId = "bootstrap";
const string testPackageVersion = "3.0.0";
await ApplicationManager.RunAsync(appName, async appManager =>
{
var manager = appManager.SiteExtensionManager;
// list package
TestTracer.Trace("Search extensions by id: '{0}'", testPackageId);
IEnumerable <SiteExtensionInfo> results = await manager.GetRemoteExtensions(
filter: testPackageId,
feedUrl: feedEndpoint);
Assert.True(results.Count() > 0, string.Format("GetRemoteExtensions for '{0}' package result should > 0", testPackageId));
// get package
TestTracer.Trace("Get an extension by id: '{0}'", testPackageId);
SiteExtensionInfo result = await manager.GetRemoteExtension(testPackageId, feedUrl: feedEndpoint);
Assert.Equal(testPackageId, result.Id);
TestTracer.Trace("Get an extension by id: '{0}' and version: '{1}'", testPackageId, testPackageVersion);
result = await manager.GetRemoteExtension(testPackageId, version: testPackageVersion, feedUrl: feedEndpoint);
Assert.Equal(testPackageId, result.Id);
Assert.Equal(testPackageVersion, result.Version);
// install
TestTracer.Trace("Install an extension by id: '{0}' and version: '{1}'", testPackageId, testPackageVersion);
HttpResponseResult <SiteExtensionInfo> richResult = await manager.InstallExtension <SiteExtensionInfo>(testPackageId, version: testPackageVersion, feedUrl: feedEndpoint);
Assert.Equal(testPackageId, richResult.Body.Id);
Assert.Equal(testPackageVersion, richResult.Body.Version);
Assert.False(richResult.Headers.ContainsKey(Constants.SiteOperationHeaderKey)); // only ARM request will have SiteOperation header
// uninstall
TestTracer.Trace("Uninstall an extension by id: '{0}'", testPackageId);
Assert.True(await manager.UninstallExtension(testPackageId));
});
}
private void VerifyTriggeredJobTriggers(ApplicationManager appManager, string jobName, int expectedNumberOfRuns, string expectedStatus, string expectedOutput = null, string expectedError = null, string arguments = null, bool scheduledTriggeredJob = false)
{
if (!scheduledTriggeredJob)
{
appManager.JobsManager.InvokeTriggeredJobAsync(jobName, arguments).Wait();
}
try
{
WaitUntilAssertVerified(
"verify triggered job run",
TimeSpan.FromSeconds(30),
() =>
{
TriggeredJobHistory triggeredJobHistory = appManager.JobsManager.GetTriggeredJobHistoryAsync(jobName).Result;
Assert.NotNull(triggeredJobHistory);
Assert.Equal(expectedNumberOfRuns, triggeredJobHistory.TriggeredJobRuns.Count());
TriggeredJobRun triggeredJobRun = triggeredJobHistory.TriggeredJobRuns.FirstOrDefault();
AssertTriggeredJobRun(appManager, triggeredJobRun, jobName, expectedStatus, expectedOutput, expectedError);
});
}
catch
{
// On error trace the scheduler log if it is a scheduler job
if (scheduledTriggeredJob)
{
try
{
string schedulerLog = appManager.VfsManager.ReadAllText(JobsDataPath + "/triggered/" + jobName + "/job_scheduler.log");
TestTracer.Trace("Scheduler log - " + schedulerLog);
}
catch
{
}
}
throw;
}
}
public void TestManyTCPIPConnections()
{
LogHandler.DeleteCurrentDefaultLog();
const int count = 1000;
List <TcpConnection> sockets = new List <TcpConnection>();
for (int i = 1; i <= count; i++)
{
TcpConnection socket = new TcpConnection();
Assert.IsTrue(socket.Connect(25));
if ((i % 10) == 0)
{
TestTracer.WriteTraceInfo("{0}/{1}", i, 1000);
}
sockets.Add(socket);
}
foreach (TcpConnection socket in sockets)
{
socket.Disconnect();
}
RetryHelper.TryAction(() =>
{
string log = LogHandler.ReadCurrentDefaultLog();
string connectionCreated = "TCP - 127.0.0.1 connected to 127.0.0.1:25.";
string connectionEnded = "Ending session ";
var created = Regex.Matches(log, connectionCreated);
var ended = Regex.Matches(log, connectionEnded);
Assert.AreEqual(count, created.Count);
Assert.AreEqual(count, ended.Count);
}, TimeSpan.FromSeconds(1), TimeSpan.FromSeconds(30));
}
public void TestSendViaSpamAssassin()
{
CustomAsserts.AssertSpamAssassinIsRunning();
SingletonProvider <TestSetup> .Instance.GetApp().Settings.AntiSpam.SpamAssassinEnabled = true;
string dataDir =
Path.Combine(SingletonProvider <TestSetup> .Instance.GetApp().Settings.Directories.DataDirectory, "test.com");
string accountDir = Path.Combine(dataDir, "test");
int memoryUsage = Shared.GetCurrentMemoryUsage();
int maxMemoryUsage = memoryUsage + 2;
const int numberOfMessages = 100;
var mail = new MailMessage();
mail.From = new MailAddress("*****@*****.**");
mail.To.Add("*****@*****.**");
mail.Subject = "Automatic server test";
mail.Body = "Automatic server test";
mail.BodyEncoding = Encoding.GetEncoding(1252);
mail.SubjectEncoding = Encoding.GetEncoding(1252);
for (int i = 1; i <= numberOfMessages; i++)
{
var oClient = new SmtpClient("localhost", 25);
oClient.Send(mail);
if (i % 5 == 0)
{
Shared.AssertLowMemoryUsage(maxMemoryUsage);
TestTracer.WriteTraceInfo("{0}/{1}", i, numberOfMessages);
}
}
WaitForFilesInFolder(accountDir, numberOfMessages);
_domain.Delete();
}
public void TestLongSMTPCommand()
{
var socket = new TcpConnection();
socket.Connect(25);
// Build a large string...
var sb = new StringBuilder();
sb.Append("A01");
for (int i = 0; i < 1000000; i++)
{
sb.Append("01234567890");
}
sb.Append(Environment.NewLine);
for (int i = 0; i < 100; i++)
{
try
{
socket.Send(sb.ToString());
}
catch (Exception)
{
return;
}
if ((i % 10) == 0)
{
TestTracer.WriteTraceInfo("{0}/{1}", i, 100);
}
}
socket.Send("\r\n");
socket.Receive();
socket.Disconnect();
}
public async Task DiagnosticsDumpTests()
{
string appName = "DiagnosticsDumpTests";
await ApplicationManager.RunAsync(appName, async appManager =>
{
string path = String.Format("dump?marker={0}", Guid.NewGuid());
using (HttpClient client = HttpClientHelper.CreateClient(appManager.ServiceUrl, appManager.DeploymentManager.Credentials))
{
using (var zipStream = new MemoryStream())
{
using (var dump = await client.GetStreamAsync(path))
{
Assert.NotNull(dump);
await dump.CopyToAsync(zipStream);
}
TestTracer.Trace("zipStream lenth={0}", zipStream.Length);
Assert.True(zipStream.Length > 0);
zipStream.Position = 0;
using (var targetStream = new MemoryStream())
{
ZipUtils.Unzip(zipStream, targetStream);
TestTracer.Trace("targetStream lenth={0}", targetStream.Length);
Assert.True(targetStream.Length > 0);
}
}
}
// Ensure trace
string trace = await appManager.VfsManager.ReadAllTextAsync("LogFiles/kudu/trace/");
Assert.Contains("_GET_dump_200_", trace, StringComparison.OrdinalIgnoreCase);
Assert.Contains("s.xml", trace, StringComparison.OrdinalIgnoreCase);
Assert.Contains("_GET_api-vfs-LogFiles-kudu-trace_pending.xml", trace, StringComparison.OrdinalIgnoreCase);
// Test runtime object by checking for one Node version
RuntimeInfo runtimeInfo = await appManager.RuntimeManager.GetRuntimeInfo();
Assert.True(runtimeInfo.NodeVersions.Any(dict => dict["version"] == "0.8.2"));
});
}
private async Task AssertUrlContentAsync(ApplicationManager appManager, Uri requestUrl, string expectedContent)
{
if (expectedContent == null)
{
Assert.Null(requestUrl);
return;
}
string address = requestUrl.ToString();
using (var httpClient = HttpClientHelper.CreateClient(address, appManager.JobsManager.Credentials))
{
using (var response = await httpClient.GetAsync(String.Empty))
{
var content = await response.Content.ReadAsStringAsync();
TestTracer.Trace("Request to: {0}\nStatus code: {1}\nContent: {2}", address, response.StatusCode, content);
Assert.True(content.IndexOf(expectedContent, StringComparison.OrdinalIgnoreCase) >= 0, "Expected content: " + expectedContent);
}
}
}
public Task TestAsyncZipDeployment()
{
return(ApplicationManager.RunAsync("TestAsyncZipDeployment", async appManager =>
{
// Big enough to require at least a couple polls for status until success
var files = CreateRandomFilesForZip(1000);
var response = await DeployZip(appManager, files, doAsync: true);
response.EnsureSuccessStatusCode();
TestTracer.Trace("Confirming deployment is in progress");
DeployResult result;
do
{
result = await appManager.DeploymentManager.GetResultAsync("latest");
Assert.Equal("Zip-Push", result.Deployer);
await Task.Delay(TimeSpan.FromSeconds(2));
} while (!new[] { DeployStatus.Failed, DeployStatus.Success }.Contains(result.Status));
await AssertSuccessfulDeploymentByFilenames(appManager, files.Select(f => f.Filename).ToArray());
}));
}
public void TriggeredJobAcceptsArguments()
{
RunScenario("TriggeredJobAcceptsArguments", appManager =>
{
const string jobName = "job1";
TestTracer.Trace("Copying the script to the triggered job directory");
appManager.JobsManager.CreateTriggeredJobAsync(jobName, "run.cmd", "echo %*").Wait();
var expectedTriggeredJob = new TriggeredJob()
{
Name = jobName,
JobType = "triggered",
RunCommand = "run.cmd"
};
TestTracer.Trace("Trigger the job");
VerifyTriggeredJobTriggers(appManager, jobName, 1, "Success", "echo test arguments", expectedError: null, arguments: "test arguments");
});
}
public void ContinuousJobStopsWhenDisabledStartsWhenEnabled()
{
RunScenario("ContinuousJobStopsWhenDisabledStartsWhenEnabled", appManager =>
{
using (TestRepository testRepository = Git.Clone("ConsoleWorker"))
{
TestTracer.Trace("Starting ConsoleWorker test, deploying the worker");
PushAndVerifyConsoleWorker(appManager, testRepository, new string[] { ExpectedVerificationFileContent });
TestTracer.Trace("Make sure process is up");
var processes = appManager.ProcessManager.GetProcessesAsync().Result;
var workerProcess = processes.FirstOrDefault(p => String.Equals("ConsoleWorker", p.Name, StringComparison.OrdinalIgnoreCase));
Assert.NotNull(workerProcess);
TestTracer.Trace("Disable this job");
appManager.JobsManager.DisableContinuousJobAsync("deployedJob").Wait();
VerifyContinuousJobDisabled(appManager);
TestTracer.Trace("Enable this job");
appManager.JobsManager.EnableContinuousJobAsync("deployedJob").Wait();
VerifyContinuousJobEnabled(appManager);
TestTracer.Trace("Disable all WebJobs");
appManager.SettingsManager.SetValue(SettingsKeys.WebJobsStopped, "1").Wait();
RestartServiceSite(appManager);
VerifyContinuousJobDisabled(appManager);
TestTracer.Trace("Enable all WebJobs");
appManager.SettingsManager.SetValue(SettingsKeys.WebJobsStopped, "0").Wait();
RestartServiceSite(appManager);
VerifyContinuousJobEnabled(appManager);
}
});
}
private void WaitUntilAssertVerified(string description, TimeSpan maxWaitTime, Action assertAction)
{
TestTracer.Trace("Waiting for " + description);
Stopwatch waitTime = Stopwatch.StartNew();
while (waitTime.Elapsed < maxWaitTime)
{
try
{
assertAction();
return;
}
catch
{
}
Thread.Sleep(1000);
}
assertAction();
}
public void JobsSettingsSetSuccessfully()
{
RunScenario("JobsSettingsSetSuccessfully", appManager =>
{
const string triggeredJobName = "triggeredJob";
const string continuousJobName = "continuousJob";
const string settingKey = "mysetting";
const string settingValue = "myvalue";
TestTracer.Trace("Creating a triggered job and creating a continuous job");
appManager.JobsManager.CreateTriggeredJobAsync(triggeredJobName, "run.cmd", JobScript).Wait();
appManager.JobsManager.CreateContinuousJobAsync(continuousJobName, "run.cmd", JobScript).Wait();
TestTracer.Trace("Test update of continuous job settings");
JobSettings continuousJobSettings = appManager.JobsManager.GetContinuousJobSettingsAsync(continuousJobName).Result;
Assert.Equal(null, continuousJobSettings.GetSetting <string>(settingKey));
continuousJobSettings.SetSetting(settingKey, settingValue);
appManager.JobsManager.SetContinuousJobSettingsAsync(continuousJobName, continuousJobSettings).Wait();
continuousJobSettings = appManager.JobsManager.GetContinuousJobSettingsAsync(continuousJobName).Result;
Assert.Equal(settingValue, continuousJobSettings.GetSetting <string>(settingKey));
TestTracer.Trace("Test update of triggered job settings");
JobSettings triggeredJobSettings = appManager.JobsManager.GetTriggeredJobSettingsAsync(triggeredJobName).Result;
Assert.Equal(null, triggeredJobSettings.GetSetting <string>(settingKey));
triggeredJobSettings.SetSetting(settingKey, settingValue);
appManager.JobsManager.SetTriggeredJobSettingsAsync(triggeredJobName, triggeredJobSettings).Wait();
triggeredJobSettings = appManager.JobsManager.GetTriggeredJobSettingsAsync(triggeredJobName).Result;
Assert.Equal(settingValue, triggeredJobSettings.GetSetting <string>(settingKey));
});
}
public async Task SiteExtensionShouldDeployWebJobs()
{
const string appName = "SiteExtensionShouldDeployWebJobs";
await ApplicationManager.RunAsync(appName, async appManager =>
{
var manager = appManager.SiteExtensionManager;
await CleanSiteExtensions(manager);
TestTracer.Trace("Install site extension with jobs");
await manager.InstallExtension("filecounterwithwebjobs", null, "https://www.myget.org/F/amitaptest/");
TestTracer.Trace("Verify jobs were deployed");
await OperationManager.AttemptAsync(async() =>
{
var continuousJobs = (await appManager.JobsManager.ListContinuousJobsAsync()).ToArray();
Assert.Equal(1, continuousJobs.Length);
Assert.Equal("filecounterwithwebjobs(cjoba)", continuousJobs[0].Name);
TestTracer.Trace("Job status - {0}", continuousJobs[0].Status);
Assert.Equal("PendingRestart", continuousJobs[0].Status);
}, 100, 500);
var triggeredJobs = (await appManager.JobsManager.ListTriggeredJobsAsync()).ToArray();
Assert.Equal(2, triggeredJobs.Length);
Assert.Equal("filecounterwithwebjobs(tjoba)", triggeredJobs[0].Name);
Assert.Equal("filecounterwithwebjobs(tjobb)", triggeredJobs[1].Name);
TestTracer.Trace("Uninstall site extension with jobs");
await manager.UninstallExtension("filecounterwithwebjobs");
TestTracer.Trace("Verify jobs removed");
var continuousJobs2 = (await appManager.JobsManager.ListContinuousJobsAsync()).ToArray();
Assert.Equal(0, continuousJobs2.Length);
triggeredJobs = (await appManager.JobsManager.ListTriggeredJobsAsync()).ToArray();
Assert.Equal(0, triggeredJobs.Length);
});
}
private static async Task<string> DeployNonZippedArtifact(
ApplicationManager appManager,
string type,
string path,
bool isAsync)
{
TestTracer.Trace("Deploying file");
var testFile = DeploymentTestHelper.CreateRandomTestFile();
using (var fileStream = DeploymentTestHelper.CreateFileStream(testFile))
{
IList<KeyValuePair<string, string>> queryParams = GetOneDeployQueryParams(type, path, isAsync);
var response = await appManager.OneDeployManager.PushDeployFromStream(fileStream, new ZipDeployMetadata(), queryParams);
response.EnsureSuccessStatusCode();
if (isAsync)
{
await DeploymentTestHelper.WaitForDeploymentCompletionAsync(appManager, deployer);
}
}
return testFile.Content;
}
private void CleanupTest(ApplicationManager appManager)
{
WaitUntilAssertVerified(
"clean site for jobs",
TimeSpan.FromSeconds(60),
() =>
{
TestTracer.Trace($"CleanupTest: Delete {JobsBinPath}");
appManager.VfsManager.Delete(JobsBinPath, recursive: true);
TestTracer.Trace($"CleanupTest: Delete {JobsDataPath}");
appManager.VfsManager.Delete(JobsDataPath, recursive: true);
var logFiles = appManager.VfsManager.ListAsync("LogFiles").Result;
foreach (var logFile in logFiles)
{
if (logFile.Name.StartsWith("appSettings.txt", StringComparison.OrdinalIgnoreCase) ||
logFile.Name.StartsWith("verification.txt", StringComparison.OrdinalIgnoreCase))
{
TestTracer.Trace($"CleanupTest: Delete LogFiles/{logFile.Name}");
appManager.VfsManager.Delete("LogFiles/" + logFile.Name);
}
}
foreach (var job in appManager.JobsManager.ListTriggeredJobsAsync().Result)
{
TestTracer.Trace($"CleanupTest: DeleteTriggeredJobAsync {job.Name}");
appManager.JobsManager.DeleteTriggeredJobAsync(job.Name).Wait();
}
foreach (var job in appManager.JobsManager.ListContinuousJobsAsync().Result)
{
TestTracer.Trace($"CleanupTest: DeleteContinuousJobAsync {job.Name}");
appManager.JobsManager.DeleteContinuousJobAsync(job.Name).Wait();
}
});
}
private static async Task <HttpResponseMessage> DeployWar(
ApplicationManager appManager,
FileForZip[] files,
ZipDeployMetadata metadata,
string appName = null)
{
TestTracer.Trace("Push-deploying war");
using (var zipStream = CreateZipStream(files))
{
IList <KeyValuePair <string, string> > queryParams = null;
if (!string.IsNullOrWhiteSpace(appName))
{
queryParams = new List <KeyValuePair <string, string> >()
{
new KeyValuePair <string, string>("name", appName)
};
}
return(await appManager.WarDeploymentManager.PushDeployFromStream(
zipStream,
metadata,
queryParams));
}
}
private static async Task AssertSuccessfulDeploymentByContent(ApplicationManager appManager, FileForZip[] files)
{
TestTracer.Trace("Verifying files are deployed and deployment record created.");
var deployment = await appManager.DeploymentManager.GetResultAsync("latest");
Assert.Equal(DeployStatus.Success, deployment.Status);
Assert.Equal(ZipDeployer, deployment.Deployer);
var entries = await appManager.VfsWebRootManager.ListAsync(null);
var deployedFilenames = entries.Select(e => e.Name);
var filenameSet = new HashSet <string>(files.Select(f => f.Filename));
Assert.True(filenameSet.SetEquals(entries.Select(e => e.Name)));
foreach (var file in files)
{
var deployedContent = await appManager.VfsWebRootManager.ReadAllTextAsync(file.Filename);
Assert.Equal(file.Content, deployedContent);
}
}
public void TestSend200KMessages()
{
string dataDir =
Path.Combine(SingletonProvider <TestSetup> .Instance.GetApp().Settings.Directories.DataDirectory, "test.com");
string accountDir = Path.Combine(dataDir, "test");
int memoryUsage = Shared.GetCurrentMemoryUsage();
int maxMemoryUsage = memoryUsage + 5;
const int numberOfMessages = 200000;
for (int i = 1; i <= numberOfMessages; i++)
{
Assert.IsTrue(SMTPClientSimulator.StaticSend("*****@*****.**", "*****@*****.**", "Test", "Test message"));
if (i % 100 == 0)
{
Shared.AssertLowMemoryUsage(maxMemoryUsage);
TestTracer.WriteTraceInfo("{0}/{1}", i, numberOfMessages);
}
}
// Check number of delivered messages.
RetryHelper.TryAction(() =>
{
Shared.AssertLowMemoryUsage(maxMemoryUsage);
int actualNumberOfMessages = GetNumberOfFilesInFolder(accountDir);
TestTracer.WriteTraceInfo("{0}/{1}", actualNumberOfMessages, numberOfMessages);
Assert.AreEqual(numberOfMessages, actualNumberOfMessages);
}, TimeSpan.FromSeconds(30), TimeSpan.FromHours(12));
_domain.Delete();
}
private async Task VerifyWebHooksCall(IEnumerable <string> hookAddresses, ApplicationManager hookAppManager, params string[] expectedContents)
{
TestTracer.Trace("Verify web hook was called {0} times".FormatCurrentCulture(hookAddresses.Count()));
string webHookCallResponse = await GetWebHookResponseAsync(hookAppManager.SiteUrl);
string[] webHookResults = webHookCallResponse.Split(new char[] { '\n' }, StringSplitOptions.RemoveEmptyEntries);
Assert.Equal(hookAddresses.Count(), webHookResults.Count());
foreach (var hookAddress in hookAddresses)
{
bool found = false;
foreach (var webHookResult in webHookResults)
{
dynamic webHookResultObject = JsonConvert.DeserializeObject(webHookResult);
if (("/" + hookAddress) == (string)webHookResultObject.url)
{
var body = (string)webHookResultObject.body;
found = true;
// Make sure body json
JsonConvert.DeserializeObject(body);
foreach (var expectedContent in expectedContents)
{
Assert.Contains(expectedContent, body, StringComparison.OrdinalIgnoreCase);
}
}
}
Assert.True(found, "Web hook address {0} was not called".FormatCurrentCulture(hookAddress));
}
hookAppManager.VfsWebRootManager.Delete("result.txt");
}
public void PostDeploymentActionsShouldNotBeCalledOnFailedDeployment()
{
string testName = "PostDeploymentActionsShouldNotBeCalledOnFailedDeployment";
string testLine1 = "test script 1 is running";
string testLine2 = "test script 2 is running too";
using (new LatencyLogger(testName))
{
ApplicationManager.Run(testName, appManager =>
{
using (var appRepository = Git.Clone("WarningsAsErrors"))
{
TestTracer.Trace("Add action scripts");
appManager.VfsManager.WriteAllText(
@"site\deployments\tools\PostDeploymentActions\test_script_1.cmd",
@"@echo off
echo " + testLine1);
appManager.VfsManager.WriteAllText(
@"site\deployments\tools\PostDeploymentActions\test_script_2.bat",
@"@echo off
echo " + testLine2);
TestTracer.Trace("Deploy test app");
appManager.GitDeploy(appRepository.PhysicalPath);
TestTracer.Trace("Verify results");
var deploymentResults = appManager.DeploymentManager.GetResultsAsync().Result.ToList();
Assert.Equal(1, deploymentResults.Count);
Assert.Equal(DeployStatus.Failed, deploymentResults[0].Status);
KuduAssert.VerifyLogOutputWithUnexpected(appManager, deploymentResults[0].Id, testLine1, testLine2);
}
});
}
}
public async Task SiteExtensionBasicTests()
{
const string appName = "SiteExtensionBasicTests";
const string installationArgument = "arg0";
await ApplicationManager.RunAsync(appName, async appManager =>
{
var manager = appManager.SiteExtensionManager;
await CleanSiteExtensions(manager);
// list
List <SiteExtensionInfo> results = await(await manager.GetRemoteExtensions()).Content.ReadAsAsync <List <SiteExtensionInfo> >();
Assert.True(results.Any(), "GetRemoteExtensions expects results > 0");
// pick site extension
var expectedId = _galleryInstalledExtensions.Keys.ToArray()[new Random().Next(_galleryInstalledExtensions.Count)];
var expectedInstallationArgs = installationArgument;
var expected = results.Find(ext => string.Equals(ext.Id, expectedId, StringComparison.OrdinalIgnoreCase));
Assert.True(expected != null, string.Format(CultureInfo.InvariantCulture, "Should able to find {0} from search result", expectedId));
TestTracer.Trace("Testing Against Site Extension '{0}' - '{1}'", expectedId, expected.Version);
// get
TestTracer.Trace("Perform GetRemoteExtension with id '{0}' only", expectedId);
HttpResponseMessage responseMessage = await manager.GetRemoteExtension(expectedId);
SiteExtensionInfo result = await responseMessage.Content.ReadAsAsync <SiteExtensionInfo>();
Assert.Equal(expected.Id, result.Id);
Assert.True(responseMessage.Headers.Contains(Constants.RequestIdHeader));
// clear local extensions
TestTracer.Trace("Clear all installed extensions.");
results = await(await manager.GetLocalExtensions()).Content.ReadAsAsync <List <SiteExtensionInfo> >();
HttpResponseMessage deleteResponseMessage = null;
foreach (var ext in results)
{
deleteResponseMessage = await manager.UninstallExtension(ext.Id);
Assert.True(await deleteResponseMessage.Content.ReadAsAsync <bool>(), "Delete must return true");
Assert.True(deleteResponseMessage.Headers.Contains(Constants.RequestIdHeader));
}
// install/update
TestTracer.Trace("Perform InstallExtension with id '{0}' and installationArgs '{1}'", expectedId, installationArgument);
responseMessage = await manager.InstallExtension(expected.Id, installationArgs: installationArgument);
result = await responseMessage.Content.ReadAsAsync <SiteExtensionInfo>();
Assert.Equal(expected.Id, result.Id);
Assert.Equal(expected.Version, result.Version);
Assert.Equal(expectedInstallationArgs, result.InstallationArgs);
Assert.True(responseMessage.Headers.Contains(Constants.RequestIdHeader));
// list
TestTracer.Trace("Perform GetLocalExtensions with no parameter");
results = await(await manager.GetLocalExtensions()).Content.ReadAsAsync <List <SiteExtensionInfo> >();
Assert.True(results.Any(), "GetLocalExtensions expects results > 0");
// get
TestTracer.Trace("Perform GetLocalExtension with id '{0}' only.", expectedId);
responseMessage = await manager.GetLocalExtension(expected.Id);
result = await responseMessage.Content.ReadAsAsync <SiteExtensionInfo>();
Assert.Equal(expected.Id, result.Id);
Assert.Equal(expectedInstallationArgs, result.InstallationArgs);
Assert.True(responseMessage.Headers.Contains(Constants.RequestIdHeader));
// delete
TestTracer.Trace("Perform UninstallExtension with id '{0}' only.", expectedId);
responseMessage = await manager.UninstallExtension(expected.Id);
bool deleteResult = await responseMessage.Content.ReadAsAsync <bool>();
Assert.True(deleteResult, "Delete must return true");
Assert.True(responseMessage.Headers.Contains(Constants.RequestIdHeader));
// list installed
TestTracer.Trace("Verify only '{0}' is installed", expectedId);
results = await(await manager.GetLocalExtensions()).Content.ReadAsAsync <List <SiteExtensionInfo> >();
Assert.False(results.Exists(ext => ext.Id == expected.Id), "After deletion extension " + expected.Id + " should not exist.");
// install from non-default endpoint
responseMessage = await manager.InstallExtension("filecounter", version: "1.0.19", feedUrl: "https://www.nuget.org/api/v2/", installationArgs: installationArgument);
result = await responseMessage.Content.ReadAsAsync <SiteExtensionInfo>();
Assert.Equal("filecounter", result.Id);
Assert.Equal("1.0.19", result.Version);
Assert.Equal("https://www.nuget.org/api/v2/", result.FeedUrl);
Assert.Equal(expectedInstallationArgs, result.InstallationArgs);
Assert.True(responseMessage.Headers.Contains(Constants.RequestIdHeader));
// update site extension installed from non-default endpoint with no installation arguments
responseMessage = await manager.InstallExtension("filecounter");
result = await responseMessage.Content.ReadAsAsync <SiteExtensionInfo>();
Assert.Equal("filecounter", result.Id);
Assert.Equal("https://www.nuget.org/api/v2/", result.FeedUrl);
Assert.True(string.IsNullOrWhiteSpace(result.InstallationArgs));
Assert.True(responseMessage.Headers.Contains(Constants.RequestIdHeader));
// update site extension installed using installation arguments
responseMessage = await manager.InstallExtension("filecounter", installationArgs: installationArgument);
result = await responseMessage.Content.ReadAsAsync <SiteExtensionInfo>();
Assert.Equal("filecounter", result.Id);
Assert.Equal("https://www.nuget.org/api/v2/", result.FeedUrl);
Assert.Equal(expectedInstallationArgs, result.InstallationArgs);
Assert.True(responseMessage.Headers.Contains(Constants.RequestIdHeader));
});
}
public async Task SiteExtensionInstallPackageToWebRootAsyncTests()
{
const string appName = "SiteExtensionInstallPackageToWebRootAsyncTests";
const string externalPackageId = "SimpleSvc";
const string externalPackageVersion = "1.0.0";
const string externalFeed = "https://www.myget.org/F/simplesvc/";
// site extension 'webrootxdttest' search for xdt files under site extension 'webrootxdttest' folder, and print out xdt content onto page
const string externalPackageWithXdtId = "webrootxdttest";
await ApplicationManager.RunAsync(appName, async appManager =>
{
var manager = appManager.SiteExtensionManager;
await CleanSiteExtensions(manager);
// install/update
TestTracer.Trace("Perform InstallExtension with id '{0}', version '{1}' from '{2}'", externalPackageId, externalPackageVersion, externalFeed);
UpdateHeaderIfGoingToBeArmRequest(manager.Client, true);
HttpResponseMessage responseMessage = await manager.InstallExtension(externalPackageId, externalPackageVersion, externalFeed, SiteExtensionInfo.SiteExtensionType.WebRoot);
ArmEntry <SiteExtensionInfo> armResult = null;
if (responseMessage.StatusCode == HttpStatusCode.OK)
{
TestTracer.Trace("Installation done within 15 seconds, no polling needed.");
armResult = await responseMessage.Content.ReadAsAsync <ArmEntry <SiteExtensionInfo> >();
}
else
{
Assert.Equal(HttpStatusCode.Created, responseMessage.StatusCode);
responseMessage = await PollAndVerifyAfterArmInstallation(manager, externalPackageId);
armResult = await responseMessage.Content.ReadAsAsync <ArmEntry <SiteExtensionInfo> >();
}
// shouldn`t see restart header since package doesn`t come with XDT
Assert.False(responseMessage.Headers.Contains(Constants.SiteOperationHeaderKey), "Must not contain restart header");
Assert.Equal(externalFeed, armResult.Properties.FeedUrl);
Assert.Equal(externalPackageVersion, armResult.Properties.Version);
Assert.Equal(HttpStatusCode.OK, responseMessage.StatusCode);
TestTracer.Trace("GET request to verify package content has been copied to wwwroot");
HttpClient client = new HttpClient();
responseMessage = await client.GetAsync(appManager.SiteUrl);
string responseContent = await responseMessage.Content.ReadAsStringAsync();
Assert.NotNull(responseContent);
Assert.True(responseContent.Contains(@"<h3>Site for testing</h3>"));
TestTracer.Trace("GetLocalExtension should return WebRoot type SiteExtensionInfo");
responseMessage = await manager.GetLocalExtension(externalPackageId);
armResult = await responseMessage.Content.ReadAsAsync <ArmEntry <SiteExtensionInfo> >();
Assert.Equal(SiteExtensionInfo.SiteExtensionType.WebRoot, armResult.Properties.Type);
responseMessage = await manager.GetLocalExtensions(externalPackageId);
var results = await responseMessage.Content.ReadAsAsync <ArmListEntry <SiteExtensionInfo> >();
foreach (var item in results.Value)
{
if (string.Equals(externalPackageId, item.Properties.Id, StringComparison.OrdinalIgnoreCase))
{
Assert.Equal(SiteExtensionInfo.SiteExtensionType.WebRoot, item.Properties.Type);
}
}
// delete
TestTracer.Trace("Perform UninstallExtension with id '{0}' only.", externalPackageId);
responseMessage = await manager.UninstallExtension(externalPackageId);
armResult = await responseMessage.Content.ReadAsAsync <ArmEntry <SiteExtensionInfo> >();
Assert.Null(armResult);
Assert.Equal(HttpStatusCode.OK, responseMessage.StatusCode);
TestTracer.Trace("GET request to verify package content has been removed wwwroot");
responseMessage = await client.GetAsync(appManager.SiteUrl);
Assert.Equal(HttpStatusCode.Forbidden, responseMessage.StatusCode);
// install package that with xdt file
TestTracer.Trace("Perform InstallExtension with id '{0}' from '{1}'", externalPackageWithXdtId, externalFeed);
responseMessage = await manager.InstallExtension(externalPackageWithXdtId, feedUrl: externalFeed, type: SiteExtensionInfo.SiteExtensionType.WebRoot);
Assert.Equal(HttpStatusCode.Created, responseMessage.StatusCode);
Assert.True(responseMessage.Headers.Contains(Constants.RequestIdHeader));
// package come with XDT, which would require site restart
TestTracer.Trace("Poll for status. Expecting 200 response eventually with site operation header.");
responseMessage = await PollAndVerifyAfterArmInstallation(manager, externalPackageWithXdtId);
armResult = await responseMessage.Content.ReadAsAsync <ArmEntry <SiteExtensionInfo> >();
// after successfully installed, should return SiteOperationHeader to notify GEO to restart website
Assert.True(responseMessage.Headers.Contains(Constants.SiteOperationHeaderKey));
Assert.Equal(externalFeed, armResult.Properties.FeedUrl);
Assert.Equal(HttpStatusCode.OK, responseMessage.StatusCode);
TestTracer.Trace("GET request to verify package content has been copied to wwwroot");
responseMessage = await client.GetAsync(appManager.SiteUrl);
responseContent = await responseMessage.Content.ReadAsStringAsync();
Assert.NotNull(responseContent);
Assert.True(responseContent.Contains(@"1 files"));
Assert.True(responseContent.Contains(@"site\path\shall\not\be\found")); // xdt content
});
}
public async Task SiteExtensionShouldNotSeeButAbleToInstallUnlistedPackage()
{
const string appName = "SiteExtensionShouldNotSeeUnlistPackage";
const string externalPackageId = "SimpleSite";
const string unlistedVersion = "3.0.0";
const string latestListedVersion = "2.0.0";
const string externalFeed = "https://www.myget.org/F/simplesvc/";
await ApplicationManager.RunAsync(appName, async appManager =>
{
var manager = appManager.SiteExtensionManager;
await CleanSiteExtensions(manager);
HttpResponseMessage response = await manager.GetRemoteExtension(externalPackageId, feedUrl: externalFeed);
SiteExtensionInfo info = await response.Content.ReadAsAsync <SiteExtensionInfo>();
Assert.NotEqual(unlistedVersion, info.Version);
response = await manager.GetRemoteExtension(externalPackageId, version: unlistedVersion, feedUrl: externalFeed);
info = await response.Content.ReadAsAsync <SiteExtensionInfo>();
Assert.Equal(unlistedVersion, info.Version);
response = await manager.GetRemoteExtensions(externalPackageId, allowPrereleaseVersions: true, feedUrl: externalFeed);
List <SiteExtensionInfo> infos = await response.Content.ReadAsAsync <List <SiteExtensionInfo> >();
Assert.NotEmpty(infos);
foreach (var item in infos)
{
Assert.NotEqual(unlistedVersion, item.Version);
}
response = await manager.InstallExtension(externalPackageId, feedUrl: externalFeed);
info = await response.Content.ReadAsAsync <SiteExtensionInfo>();
Assert.Equal(externalPackageId, info.Id);
Assert.Equal(latestListedVersion, info.Version);
Assert.Equal(externalFeed, info.FeedUrl);
TestTracer.Trace("Should able to installed unlisted package if specify version");
response = await manager.InstallExtension(externalPackageId, version: unlistedVersion, feedUrl: externalFeed);
info = await response.Content.ReadAsAsync <SiteExtensionInfo>();
Assert.Equal(externalPackageId, info.Id);
Assert.Equal(unlistedVersion, info.Version);
Assert.Equal(externalFeed, info.FeedUrl);
UpdateHeaderIfGoingToBeArmRequest(manager.Client, isArmRequest: true);
response = await manager.GetRemoteExtension(externalPackageId, feedUrl: externalFeed);
ArmEntry <SiteExtensionInfo> armInfo = await response.Content.ReadAsAsync <ArmEntry <SiteExtensionInfo> >();
Assert.NotEqual(unlistedVersion, armInfo.Properties.Version);
response = await manager.GetRemoteExtensions(externalPackageId, allowPrereleaseVersions: true, feedUrl: externalFeed);
ArmListEntry <SiteExtensionInfo> armInfos = await response.Content.ReadAsAsync <ArmListEntry <SiteExtensionInfo> >();
Assert.NotEmpty(armInfos.Value);
foreach (var item in armInfos.Value)
{
Assert.NotEqual(unlistedVersion, item.Properties.Version);
}
response = await manager.InstallExtension(externalPackageId, feedUrl: externalFeed);
Assert.Equal(HttpStatusCode.Created, response.StatusCode);
await PollAndVerifyAfterArmInstallation(manager, externalPackageId);
response = await manager.GetLocalExtension(externalPackageId);
armInfo = await response.Content.ReadAsAsync <ArmEntry <SiteExtensionInfo> >();
Assert.Equal(externalPackageId, armInfo.Properties.Id);
Assert.Equal(latestListedVersion, armInfo.Properties.Version);
Assert.Equal(externalFeed, armInfo.Properties.FeedUrl);
response = await manager.InstallExtension(externalPackageId, version: unlistedVersion, feedUrl: externalFeed);
Assert.Equal(HttpStatusCode.Created, response.StatusCode);
await PollAndVerifyAfterArmInstallation(manager, externalPackageId);
response = await manager.GetLocalExtension(externalPackageId);
armInfo = await response.Content.ReadAsAsync <ArmEntry <SiteExtensionInfo> >();
Assert.Equal(externalPackageId, armInfo.Properties.Id);
Assert.Equal(unlistedVersion, armInfo.Properties.Version);
Assert.Equal(externalFeed, armInfo.Properties.FeedUrl);
});
}
public async Task SiteExtensionInstallPackageToWebRootTests()
{
const string appName = "SiteExtensionInstallPackageToWebRootTests";
const string externalPackageId = "SimpleSvc";
const string externalPackageVersion = "1.0.0";
const string externalFeed = "https://www.myget.org/F/simplesvc/";
// site extension 'webrootxdttest' search for xdt files under site extension 'webrootxdttest' folder, and print out xdt content onto page
const string externalPackageWithXdtId = "webrootxdttest";
await ApplicationManager.RunAsync(appName, async appManager =>
{
var manager = appManager.SiteExtensionManager;
await CleanSiteExtensions(manager);
// install/update
TestTracer.Trace("Perform InstallExtension with id '{0}', version '{1}' from '{2}'", externalPackageId, externalPackageVersion, externalFeed);
HttpResponseMessage responseMessage = await manager.InstallExtension(externalPackageId, externalPackageVersion, externalFeed, SiteExtensionInfo.SiteExtensionType.WebRoot);
SiteExtensionInfo result = await responseMessage.Content.ReadAsAsync <SiteExtensionInfo>();
Assert.Equal(externalPackageId, result.Id);
Assert.Equal(externalPackageVersion, result.Version);
Assert.Equal(externalFeed, result.FeedUrl);
TestTracer.Trace("GET request to verify package content has been copied to wwwroot");
HttpClient client = new HttpClient();
responseMessage = await client.GetAsync(appManager.SiteUrl);
string responseContent = await responseMessage.Content.ReadAsStringAsync();
Assert.NotNull(responseContent);
Assert.True(responseContent.Contains(@"<h3>Site for testing</h3>"));
TestTracer.Trace("GetLocalExtension should return WebRoot type SiteExtensionInfo");
responseMessage = await manager.GetLocalExtension(externalPackageId);
result = await responseMessage.Content.ReadAsAsync <SiteExtensionInfo>();
Assert.Equal(SiteExtensionInfo.SiteExtensionType.WebRoot, result.Type);
responseMessage = await manager.GetLocalExtensions(externalPackageId);
var results = await responseMessage.Content.ReadAsAsync <List <SiteExtensionInfo> >();
foreach (var item in results)
{
if (string.Equals(externalPackageId, item.Id, StringComparison.OrdinalIgnoreCase))
{
Assert.Equal(SiteExtensionInfo.SiteExtensionType.WebRoot, item.Type);
}
}
// delete
TestTracer.Trace("Perform UninstallExtension with id '{0}' only.", externalPackageId);
responseMessage = await manager.UninstallExtension(externalPackageId);
bool deleteResult = await responseMessage.Content.ReadAsAsync <bool>();
Assert.True(deleteResult, "Delete must return true");
TestTracer.Trace("GET request to verify package content has been removed wwwroot");
responseMessage = await client.GetAsync(appManager.SiteUrl);
Assert.Equal(HttpStatusCode.Forbidden, responseMessage.StatusCode);
// install package that with xdt file
TestTracer.Trace("Perform InstallExtension with id '{0}' from '{1}'", externalPackageWithXdtId, externalFeed);
responseMessage = await manager.InstallExtension(externalPackageWithXdtId, feedUrl: externalFeed, type: SiteExtensionInfo.SiteExtensionType.WebRoot);
result = await responseMessage.Content.ReadAsAsync <SiteExtensionInfo>();
Assert.Equal(externalPackageWithXdtId, result.Id);
Assert.Equal(externalFeed, result.FeedUrl);
TestTracer.Trace("GET request to verify package content has been copied to wwwroot");
responseMessage = await client.GetAsync(appManager.SiteUrl);
responseContent = await responseMessage.Content.ReadAsStringAsync();
Assert.NotNull(responseContent);
Assert.True(responseContent.Contains(@"1 files"));
Assert.True(responseContent.Contains(@"site\path\shall\not\be\found")); // xdt content
});
}
public async Task SiteExtensionGetArmTest()
{
const string appName = "SiteExtensionGetAsyncTest";
const string externalPackageId = "filecounter";
const string externalFeed = "https://api.nuget.org/v3/index.json";
const string installationArgument = "arg0";
await ApplicationManager.RunAsync(appName, async appManager =>
{
var manager = appManager.SiteExtensionManager;
await CleanSiteExtensions(manager);
UpdateHeaderIfGoingToBeArmRequest(manager.Client, true);
TestTracer.Trace("GetRemoteExtensions with Arm header, expecting site extension info will be wrap inside Arm envelop");
HttpResponseMessage responseMessage = await manager.GetRemoteExtensions(externalPackageId, true, externalFeed);
ArmListEntry <SiteExtensionInfo> armResultList = await responseMessage.Content.ReadAsAsync <ArmListEntry <SiteExtensionInfo> >();
Assert.Equal(HttpStatusCode.OK, responseMessage.StatusCode);
Assert.NotNull(armResultList);
Assert.NotEmpty(armResultList.Value);
Assert.NotNull(armResultList.Value.Where(item => string.Equals(externalPackageId, item.Properties.Id, StringComparison.OrdinalIgnoreCase)));
Assert.True(responseMessage.Headers.Contains(Constants.RequestIdHeader));
TestTracer.Trace("GetRemoteExtension with Arm header, expecting site extension info will be wrap inside Arm envelop");
responseMessage = await manager.GetRemoteExtension(externalPackageId, feedUrl: externalFeed);
ArmEntry <SiteExtensionInfo> armResult = await responseMessage.Content.ReadAsAsync <ArmEntry <SiteExtensionInfo> >();
Assert.Equal(HttpStatusCode.OK, responseMessage.StatusCode);
Assert.NotNull(armResult);
Assert.Equal(externalPackageId, armResult.Properties.Id);
Assert.True(responseMessage.Headers.Contains(Constants.RequestIdHeader));
UpdateHeaderIfGoingToBeArmRequest(manager.Client, false);
responseMessage = await manager.InstallExtension(externalPackageId, feedUrl: externalFeed, installationArgs: installationArgument);
SiteExtensionInfo syncResult = await responseMessage.Content.ReadAsAsync <SiteExtensionInfo>();
Assert.Equal(externalPackageId, syncResult.Id);
Assert.True(responseMessage.Headers.Contains(Constants.RequestIdHeader));
UpdateHeaderIfGoingToBeArmRequest(manager.Client, true);
TestTracer.Trace("GetLocalExtensions (no filter) with Arm header, expecting site extension info will be wrap inside Arm envelop");
responseMessage = await manager.GetLocalExtensions();
armResultList = await responseMessage.Content.ReadAsAsync <ArmListEntry <SiteExtensionInfo> >();
Assert.Equal(HttpStatusCode.OK, responseMessage.StatusCode);
Assert.NotNull(armResultList);
Assert.NotEmpty(armResultList.Value);
Assert.NotNull(armResultList.Value.Where(item => string.Equals(externalPackageId, item.Properties.Id, StringComparison.OrdinalIgnoreCase)));
Assert.Equal(Constants.SiteExtensionProvisioningStateSucceeded, armResultList.Value.First <ArmEntry <SiteExtensionInfo> >().Properties.ProvisioningState);
Assert.True(responseMessage.Headers.Contains(Constants.RequestIdHeader));
foreach (var item in armResultList.Value)
{
Assert.Equal(Constants.SiteExtensionProvisioningStateSucceeded, item.Properties.ProvisioningState);
Assert.Equal(installationArgument, item.Properties.InstallationArgs);
}
TestTracer.Trace("GetLocalExtensions (with filter) with Arm header, expecting site extension info will be wrap inside Arm envelop");
responseMessage = await manager.GetLocalExtensions(externalPackageId);
armResultList = await responseMessage.Content.ReadAsAsync <ArmListEntry <SiteExtensionInfo> >();
Assert.Equal(HttpStatusCode.OK, responseMessage.StatusCode);
Assert.NotNull(armResultList);
Assert.NotEmpty(armResultList.Value);
Assert.NotNull(armResultList.Value.Where(item => string.Equals(externalPackageId, item.Properties.Id, StringComparison.OrdinalIgnoreCase)));
Assert.True(responseMessage.Headers.Contains(Constants.RequestIdHeader));
foreach (var item in armResultList.Value)
{
Assert.Equal(Constants.SiteExtensionProvisioningStateSucceeded, item.Properties.ProvisioningState);
Assert.Equal(installationArgument, item.Properties.InstallationArgs);
}
});
}
