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); } }); }