public void USqlBuildTest()
{
using (var context = MockContext.Start(this.GetType()))
{
commonData = new CommonTestFixture(context);
commonData.HostUrl =
commonData.DataLakeAnalyticsManagementHelper.TryCreateDataLakeAnalyticsAccount(
commonData.ResourceGroupName,
commonData.Location,
commonData.DataLakeStoreAccountName,
commonData.SecondDataLakeAnalyticsAccountName
);
// Wait 5 minutes for the account setup
TestUtilities.Wait(300000);
var clientToUse = this.GetDataLakeAnalyticsJobManagementClient(context);
// Compile a usql job, which requires a jobId in the job object
// Submit a usql job to the account
var jobToBuild = new BuildJobParameters
{
Name = "azure sdk data lake analytics job",
Type = JobType.USql,
Properties = new CreateUSqlJobProperties
{
Script = "DROP DATABASE IF EXISTS testdb; CREATE DATABASE testdb;"
}
};
// Just compile the usql job, which requires a jobId in the job object
var compileResponse =
clientToUse.Job.Build(
commonData.SecondDataLakeAnalyticsAccountName,
jobToBuild
);
Assert.NotNull(compileResponse);
// Now compile a broken usql job and verify diagnostics report an error
jobToBuild.Properties.Script = "DROP DATABASE IF EXIST FOO; CREATE DATABASE FOO;";
compileResponse =
clientToUse.Job.Build(
commonData.SecondDataLakeAnalyticsAccountName,
jobToBuild
);
Assert.NotNull(compileResponse);
Assert.Equal(1, ((USqlJobProperties)compileResponse.Properties).Diagnostics.Count);
Assert.Equal(SeverityTypes.Error, ((USqlJobProperties)compileResponse.Properties).Diagnostics[0].Severity);
Assert.Equal(18, ((USqlJobProperties)compileResponse.Properties).Diagnostics[0].ColumnNumber);
Assert.Equal(22, ((USqlJobProperties)compileResponse.Properties).Diagnostics[0].End);
Assert.Equal(17, ((USqlJobProperties)compileResponse.Properties).Diagnostics[0].Start);
Assert.Equal(1, ((USqlJobProperties)compileResponse.Properties).Diagnostics[0].LineNumber);
Assert.Contains("E_CSC_USER_SYNTAXERROR", ((USqlJobProperties)compileResponse.Properties).Diagnostics[0].Message);
}
}
public void GetCatalogItemsTest()
{
// this test currently tests for Database, table TVF, view, types and procedure
using (var context = MockContext.Start(this.GetType().FullName))
{
commonData = new CommonTestFixture(context);
commonData.HostUrl =
commonData.DataLakeAnalyticsManagementHelper.TryCreateDataLakeAnalyticsAccount(commonData.ResourceGroupName,
commonData.Location, commonData.DataLakeStoreAccountName, commonData.SecondDataLakeAnalyticsAccountName);
TestUtilities.Wait(120000); // Sleep for two minutes to give the account a chance to provision the queue
commonData.DataLakeAnalyticsManagementHelper.CreateCatalog(commonData.ResourceGroupName,
commonData.SecondDataLakeAnalyticsAccountName, commonData.DatabaseName, commonData.TableName, commonData.TvfName, commonData.ViewName, commonData.ProcName);
using (var clientToUse = commonData.GetDataLakeAnalyticsCatalogManagementClient(context))
{
var dbListResponse = clientToUse.Catalog.ListDatabases(
commonData.SecondDataLakeAnalyticsAccountName);
Assert.True(dbListResponse.Count() >= 1);
// look for the DB we created
Assert.True(dbListResponse.Any(db => db.Name.Equals(commonData.DatabaseName)));
// Get the specific Database as well
var dbGetResponse = clientToUse.Catalog.GetDatabase(commonData.SecondDataLakeAnalyticsAccountName, commonData.DatabaseName);
Assert.Equal(commonData.DatabaseName, dbGetResponse.Name);
// Get the table list
var tableListResponse = clientToUse.Catalog.ListTables(
commonData.SecondDataLakeAnalyticsAccountName,
commonData.DatabaseName, CommonTestFixture.SchemaName);
Assert.True(tableListResponse.Count() >= 1);
// look for the table we created
Assert.True(tableListResponse.Any(table => table.Name.Equals(commonData.TableName)));
// Get the specific table as well
var tableGetResponse = clientToUse.Catalog.GetTable(
commonData.SecondDataLakeAnalyticsAccountName,
commonData.DatabaseName, CommonTestFixture.SchemaName, commonData.TableName);
Assert.Equal(commonData.TableName, tableGetResponse.Name);
// Get the TVF list
var tvfListResponse = clientToUse.Catalog.ListTableValuedFunctions(
commonData.SecondDataLakeAnalyticsAccountName,
commonData.DatabaseName, CommonTestFixture.SchemaName);
Assert.True(tvfListResponse.Count() >= 1);
// look for the tvf we created
Assert.True(tvfListResponse.Any(tvf => tvf.Name.Equals(commonData.TvfName)));
// Get the specific TVF as well
var tvfGetResponse = clientToUse.Catalog.GetTableValuedFunction(
commonData.SecondDataLakeAnalyticsAccountName,
commonData.DatabaseName, CommonTestFixture.SchemaName, commonData.TvfName);
Assert.Equal(commonData.TvfName, tvfGetResponse.Name);
// Get the View list
var viewListResponse = clientToUse.Catalog.ListViews(
commonData.SecondDataLakeAnalyticsAccountName,
commonData.DatabaseName, CommonTestFixture.SchemaName);
Assert.True(viewListResponse.Count() >= 1);
// look for the view we created
Assert.True(viewListResponse.Any(view => view.Name.Equals(commonData.ViewName)));
// Get the specific view as well
var viewGetResponse = clientToUse.Catalog.GetView(
commonData.SecondDataLakeAnalyticsAccountName,
commonData.DatabaseName, CommonTestFixture.SchemaName, commonData.ViewName);
Assert.Equal(commonData.ViewName, viewGetResponse.Name);
// Get the Procedure list
var procListResponse = clientToUse.Catalog.ListProcedures(
commonData.SecondDataLakeAnalyticsAccountName,
commonData.DatabaseName, CommonTestFixture.SchemaName);
Assert.True(procListResponse.Count() >= 1);
// look for the procedure we created
Assert.True(procListResponse.Any(proc => proc.Name.Equals(commonData.ProcName)));
// Get the specific procedure as well
var procGetResponse = clientToUse.Catalog.GetProcedure(
commonData.SecondDataLakeAnalyticsAccountName,
commonData.DatabaseName, CommonTestFixture.SchemaName, commonData.ProcName);
Assert.Equal(commonData.ProcName, procGetResponse.Name);
// Get the Partition list
var partitionList = clientToUse.Catalog.ListTablePartitions(
commonData.SecondDataLakeAnalyticsAccountName,
commonData.DatabaseName, CommonTestFixture.SchemaName, commonData.TableName);
Assert.True(partitionList.Count() >= 1);
var specificPartition = partitionList.First();
// Get the specific partition as well
var partitionGetResponse = clientToUse.Catalog.GetTablePartition(
commonData.SecondDataLakeAnalyticsAccountName,
commonData.DatabaseName, CommonTestFixture.SchemaName, commonData.TableName, specificPartition.Name);
Assert.Equal(specificPartition.Name, partitionGetResponse.Name);
// Get all the types
var typeGetResponse = clientToUse.Catalog.ListTypes(
commonData.SecondDataLakeAnalyticsAccountName,
commonData.DatabaseName, CommonTestFixture.SchemaName);
Assert.NotNull(typeGetResponse);
Assert.NotEmpty(typeGetResponse);
// Get all the types that are not complex
typeGetResponse = clientToUse.Catalog.ListTypes(
commonData.SecondDataLakeAnalyticsAccountName,
commonData.DatabaseName, CommonTestFixture.SchemaName, new Microsoft.Rest.Azure.OData.ODataQuery <USqlType> {
Filter = "isComplexType eq false"
});
Assert.NotNull(typeGetResponse);
Assert.NotEmpty(typeGetResponse);
Assert.False(typeGetResponse.Any(type => type.IsComplexType.Value));
}
}
}
public void SecretAndCredentialCRUDTest()
{
// NOTE: This is deprecated and will be removed in a future release
using (var context = MockContext.Start(this.GetType().FullName))
{
commonData = new CommonTestFixture(context);
commonData.HostUrl =
commonData.DataLakeAnalyticsManagementHelper.TryCreateDataLakeAnalyticsAccount(commonData.ResourceGroupName,
commonData.Location, commonData.DataLakeStoreAccountName, commonData.SecondDataLakeAnalyticsAccountName);
TestUtilities.Wait(120000); // Sleep for two minutes to give the account a chance to provision the queue
commonData.DataLakeAnalyticsManagementHelper.CreateCatalog(commonData.ResourceGroupName,
commonData.SecondDataLakeAnalyticsAccountName, commonData.DatabaseName, commonData.TableName, commonData.TvfName, commonData.ViewName, commonData.ProcName);
using (var clientToUse = commonData.GetDataLakeAnalyticsCatalogManagementClient(context))
{
using (var jobClient = commonData.GetDataLakeAnalyticsJobManagementClient(context))
{
// create the secret
var secretCreateResponse = clientToUse.Catalog.CreateSecret(
commonData.SecondDataLakeAnalyticsAccountName,
commonData.DatabaseName, commonData.SecretName,
new DataLakeAnalyticsCatalogSecretCreateOrUpdateParameters
{
Password = commonData.SecretPwd,
Uri = "https://adlasecrettest.contoso.com:443"
});
// Attempt to create the secret again, which should throw
Assert.Throws <CloudException>(
() => clientToUse.Catalog.CreateSecret(
commonData.SecondDataLakeAnalyticsAccountName,
commonData.DatabaseName, commonData.SecretName,
new DataLakeAnalyticsCatalogSecretCreateOrUpdateParameters
{
Password = commonData.SecretPwd,
Uri = "https://adlasecrettest.contoso.com:443"
}));
// create another secret
var secondSecretName = commonData.SecretName + "dup";
clientToUse.Catalog.CreateSecret(
commonData.SecondDataLakeAnalyticsAccountName,
commonData.DatabaseName, secondSecretName,
new DataLakeAnalyticsCatalogSecretCreateOrUpdateParameters
{
Password = commonData.SecretPwd,
Uri = "https://adlasecrettest.contoso.com:443"
});
// Get the secret and ensure the response contains a date.
var secretGetResponse = clientToUse.Catalog.GetSecret(
commonData.SecondDataLakeAnalyticsAccountName,
commonData.DatabaseName, commonData.SecretName);
Assert.NotNull(secretGetResponse);
Assert.NotNull(secretGetResponse.CreationTime);
// Create a credential with the secret
var credentialCreationScript =
string.Format(
@"USE {0}; CREATE CREDENTIAL {1} WITH USER_NAME = ""scope@rkm4grspxa"", IDENTITY = ""{2}"";",
commonData.DatabaseName, commonData.CredentialName, commonData.SecretName);
commonData.DataLakeAnalyticsManagementHelper.RunJobToCompletion(jobClient,
commonData.SecondDataLakeAnalyticsAccountName, TestUtilities.GenerateGuid(),
credentialCreationScript);
// Get the Credential list
var credListResponse = clientToUse.Catalog.ListCredentials(
commonData.SecondDataLakeAnalyticsAccountName,
commonData.DatabaseName);
Assert.True(credListResponse.Count() >= 1);
// look for the credential we created
Assert.True(credListResponse.Any(cred => cred.Name.Equals(commonData.CredentialName)));
// Get the specific credential as well
var credGetResponse = clientToUse.Catalog.GetCredential(
commonData.SecondDataLakeAnalyticsAccountName,
commonData.DatabaseName, commonData.CredentialName);
Assert.Equal(commonData.CredentialName, credGetResponse.Name);
// Drop the credential (to enable secret deletion)
var credentialDropScript =
string.Format(
@"USE {0}; DROP CREDENTIAL {1};", commonData.DatabaseName, commonData.CredentialName);
commonData.DataLakeAnalyticsManagementHelper.RunJobToCompletion(jobClient,
commonData.SecondDataLakeAnalyticsAccountName, TestUtilities.GenerateGuid(),
credentialDropScript);
// Delete the secret
clientToUse.Catalog.DeleteSecret(
commonData.SecondDataLakeAnalyticsAccountName,
commonData.DatabaseName, commonData.SecretName);
// Try to get the secret which should throw
Assert.Throws <CloudException>(() => clientToUse.Catalog.GetSecret(
commonData.SecondDataLakeAnalyticsAccountName,
commonData.DatabaseName, commonData.SecretName));
// Delete all secrets
clientToUse.Catalog.DeleteAllSecrets(
commonData.SecondDataLakeAnalyticsAccountName,
commonData.DatabaseName);
// Try to get the second secret, which should throw.
// Try to get the secret which should throw
Assert.Throws <CloudException>(() => clientToUse.Catalog.GetSecret(
commonData.SecondDataLakeAnalyticsAccountName,
commonData.DatabaseName, secondSecretName));
}
}
}
}
public void USqlSubmitGetListCancelTest()
{
using (var context = MockContext.Start(this.GetType()))
{
commonData = new CommonTestFixture(context);
commonData.HostUrl =
commonData.DataLakeAnalyticsManagementHelper.TryCreateDataLakeAnalyticsAccount(
commonData.ResourceGroupName,
commonData.Location,
commonData.DataLakeStoreAccountName,
commonData.SecondDataLakeAnalyticsAccountName
);
// Wait 5 minutes for the account setup
TestUtilities.Wait(300000);
var clientToUse = this.GetDataLakeAnalyticsJobManagementClient(context);
Guid jobId = TestUtilities.GenerateGuid();
Guid secondId = TestUtilities.GenerateGuid();
// Job relationship information
var recurrenceId = TestUtilities.GenerateGuid();
var recurrenceName = TestUtilities.GenerateName("recurrence");
var runId01 = TestUtilities.GenerateGuid();
var runId02 = TestUtilities.GenerateGuid();
var pipelineId = TestUtilities.GenerateGuid();
var pipelineName = TestUtilities.GenerateName("jobPipeline");
var pipelineUri = string.Format("https://{0}.contoso.com/myJob", TestUtilities.GenerateName("pipelineuri"));
// Submit a usql job to the account
var jobToSubmit = new CreateJobParameters
{
Name = "azure sdk data lake analytics job",
Type = JobType.USql,
DegreeOfParallelism = 2,
Properties = new CreateUSqlJobProperties
{
RuntimeVersion = "default",
Script = "DROP DATABASE IF EXISTS testdb; CREATE DATABASE testdb;"
},
Related = new JobRelationshipProperties
{
PipelineId = pipelineId,
PipelineName = pipelineName,
PipelineUri = pipelineUri,
RecurrenceId = recurrenceId,
RecurrenceName = recurrenceName,
RunId = runId01
}
};
// Check to make sure the usql job doesn't already exist
Assert.False(
clientToUse.Job.Exists(
commonData.SecondDataLakeAnalyticsAccountName,
jobId
)
);
// Submit the usql job
var jobCreateResponse =
clientToUse.Job.Create(
commonData.SecondDataLakeAnalyticsAccountName,
jobId,
jobToSubmit
);
Assert.NotNull(jobCreateResponse);
// Check to make sure the usql job does exist now
Assert.True(
clientToUse.Job.Exists(
commonData.SecondDataLakeAnalyticsAccountName,
jobId
)
);
// Cancel the usql job
clientToUse.Job.Cancel(
commonData.SecondDataLakeAnalyticsAccountName,
jobCreateResponse.JobId.GetValueOrDefault()
);
// Get the usql job and ensure that it says it was cancelled
var getCancelledJobResponse =
clientToUse.Job.Get(
commonData.SecondDataLakeAnalyticsAccountName,
jobCreateResponse.JobId.GetValueOrDefault()
);
Assert.Equal(JobResult.Cancelled, getCancelledJobResponse.Result);
Assert.NotNull(getCancelledJobResponse.ErrorMessage);
Assert.NotEmpty(getCancelledJobResponse.ErrorMessage);
// Resubmit the usql job
// First update the runId to a new run
jobToSubmit.Related.RunId = runId02;
jobCreateResponse =
clientToUse.Job.Create(
commonData.SecondDataLakeAnalyticsAccountName,
secondId,
jobToSubmit
);
Assert.NotNull(jobCreateResponse);
// Poll the usql job until it finishes
var getJobResponse =
clientToUse.Job.Get(
commonData.SecondDataLakeAnalyticsAccountName,
jobCreateResponse.JobId.GetValueOrDefault()
);
Assert.NotNull(getJobResponse);
int maxWaitInSeconds = 180; // 3 minutes should be long enough
int curWaitInSeconds = 0;
while (getJobResponse.State != JobState.Ended && curWaitInSeconds < maxWaitInSeconds)
{
// Wait 5 seconds before polling again
TestUtilities.Wait(5000);
curWaitInSeconds += 5;
getJobResponse =
clientToUse.Job.Get(
commonData.SecondDataLakeAnalyticsAccountName,
jobCreateResponse.JobId.GetValueOrDefault()
);
Assert.NotNull(getJobResponse);
}
Assert.True(curWaitInSeconds <= maxWaitInSeconds);
// Verify the usql job completes successfully
Assert.True(
getJobResponse.State == JobState.Ended && getJobResponse.Result == JobResult.Succeeded,
string.Format(
"Job: {0} did not return success. Current job state: {1}. Actual result: {2}. Error (if any): {3}",
getJobResponse.JobId,
getJobResponse.State,
getJobResponse.Result,
getJobResponse.ErrorMessage
)
);
// Validate usql job relationship info
Assert.Equal(runId02, getJobResponse.Related.RunId);
Assert.Equal(pipelineId, getJobResponse.Related.PipelineId);
Assert.Equal(pipelineName, getJobResponse.Related.PipelineName);
Assert.Equal(recurrenceName, getJobResponse.Related.RecurrenceName);
Assert.Equal(recurrenceId, getJobResponse.Related.RecurrenceId);
Assert.Equal(pipelineUri, getJobResponse.Related.PipelineUri);
// Get the list of usql jobs and check that the submitted job exists
var listJobResponse =
clientToUse.Job.List(
commonData.SecondDataLakeAnalyticsAccountName
);
Assert.NotNull(listJobResponse);
Assert.Contains(listJobResponse, job => job.JobId == getJobResponse.JobId);
// Validate usql job relationship retrieval (get/list pipeline and get/list recurrence)
var getPipeline =
clientToUse.Pipeline.Get(
commonData.SecondDataLakeAnalyticsAccountName,
pipelineId
);
Assert.Equal(pipelineId, getPipeline.PipelineId);
Assert.Equal(pipelineName, getPipeline.PipelineName);
Assert.Equal(pipelineUri, getPipeline.PipelineUri);
Assert.True(getPipeline.Runs.Count() >= 2);
var listPipeline =
clientToUse.Pipeline.List(
commonData.SecondDataLakeAnalyticsAccountName
);
Assert.Single(listPipeline);
Assert.Contains(listPipeline, pipeline => pipeline.PipelineId == pipelineId);
// Recurrence get/list
var getRecurrence =
clientToUse.Recurrence.Get(
commonData.SecondDataLakeAnalyticsAccountName,
recurrenceId
);
Assert.Equal(recurrenceId, getRecurrence.RecurrenceId);
Assert.Equal(recurrenceName, getRecurrence.RecurrenceName);
var listRecurrence =
clientToUse.Recurrence.List(
commonData.SecondDataLakeAnalyticsAccountName
);
Assert.Single(listRecurrence);
Assert.Contains(listRecurrence, recurrence => recurrence.RecurrenceId == recurrenceId);
// TODO: re-enable this after the next prod push
// List the usql jobs with only the jobId property filled
// listJobResponse = clientToUse.Job.List(commonData.SecondDataLakeAnalyticsAccountName, select: "jobId");
// Assert.NotNull(listJobResponse);
// Assert.True(listJobResponse.Any(job => job.JobId == getJobResponse.JobId));
}
}
public void FirewallCRUDTest()
{
using (var context = MockContext.Start(this.GetType()))
{
commonData = new CommonTestFixture(context);
var clientToUse = this.GetDataLakeAnalyticsAccountManagementClient(context);
// Create a an account with trusted ID provider and firewall rules.
var firewallStart = "127.0.0.1";
var firewallEnd = "127.0.0.2";
var firewallRuleName1 = TestUtilities.GenerateName("firerule1");
var adlaAcocunt = TestUtilities.GenerateName("adla01");
// Create a test account
var responseCreate =
clientToUse.Accounts.Create(
commonData.ResourceGroupName,
adlaAcocunt,
parameters: new CreateDataLakeAnalyticsAccountParameters
{
Location = commonData.Location,
DefaultDataLakeStoreAccount = commonData.DataLakeStoreAccountName,
DataLakeStoreAccounts = new List <AddDataLakeStoreWithAccountParameters>
{
new AddDataLakeStoreWithAccountParameters
{
Name = commonData.DataLakeStoreAccountName,
Suffix = commonData.DataLakeStoreAccountSuffix
}
},
FirewallState = FirewallState.Enabled,
FirewallAllowAzureIps = FirewallAllowAzureIpsState.Enabled,
FirewallRules = new List <CreateFirewallRuleWithAccountParameters>
{
new CreateFirewallRuleWithAccountParameters
{
Name = firewallRuleName1,
StartIpAddress = firewallStart,
EndIpAddress = firewallEnd,
}
},
}
);
Assert.Equal(DataLakeAnalyticsAccountStatus.Succeeded, responseCreate.ProvisioningState);
// Get the account and ensure that all the values are properly set.
var responseGet =
clientToUse.Accounts.Get(
commonData.ResourceGroupName,
adlaAcocunt
);
// Validate the account creation process
Assert.Equal(DataLakeAnalyticsAccountStatus.Succeeded, responseGet.ProvisioningState);
Assert.NotNull(responseCreate.Id);
Assert.NotNull(responseGet.Id);
Assert.Contains(adlaAcocunt, responseGet.Id);
Assert.Equal(commonData.Location, responseGet.Location);
Assert.Equal(adlaAcocunt, responseGet.Name);
Assert.Equal("Microsoft.DataLakeAnalytics/accounts", responseGet.Type);
// Validate firewall state
Assert.Equal(FirewallState.Enabled, responseGet.FirewallState);
Assert.True(responseGet.FirewallRules.Count() == 1);
Assert.Equal(firewallStart, responseGet.FirewallRules[0].StartIpAddress);
Assert.Equal(firewallEnd, responseGet.FirewallRules[0].EndIpAddress);
Assert.Equal(firewallRuleName1, responseGet.FirewallRules[0].Name);
Assert.Equal(FirewallAllowAzureIpsState.Enabled, responseGet.FirewallAllowAzureIps);
// Test getting the specific firewall rules
var firewallRule =
clientToUse.FirewallRules.Get(
commonData.ResourceGroupName,
adlaAcocunt,
firewallRuleName1
);
Assert.Equal(firewallStart, firewallRule.StartIpAddress);
Assert.Equal(firewallEnd, firewallRule.EndIpAddress);
Assert.Equal(firewallRuleName1, firewallRule.Name);
var updatedFirewallStart = "192.168.0.0";
var updatedFirewallEnd = "192.168.0.1";
// Update the firewall rule to change the start/end ip addresses
firewallRule =
clientToUse.FirewallRules.CreateOrUpdate(
commonData.ResourceGroupName,
adlaAcocunt,
firewallRuleName1,
parameters: new CreateOrUpdateFirewallRuleParameters
{
StartIpAddress = updatedFirewallStart,
EndIpAddress = updatedFirewallEnd,
}
);
Assert.Equal(updatedFirewallStart, firewallRule.StartIpAddress);
Assert.Equal(updatedFirewallEnd, firewallRule.EndIpAddress);
Assert.Equal(firewallRuleName1, firewallRule.Name);
// Just update the firewall rule start IP
firewallRule =
clientToUse.FirewallRules.Update(
commonData.ResourceGroupName,
adlaAcocunt,
firewallRuleName1,
parameters: new UpdateFirewallRuleParameters
{
StartIpAddress = firewallStart
}
);
Assert.Equal(firewallStart, firewallRule.StartIpAddress);
Assert.Equal(updatedFirewallEnd, firewallRule.EndIpAddress);
Assert.Equal(firewallRuleName1, firewallRule.Name);
// Remove the firewall rule and verify it is gone.
clientToUse.FirewallRules.Delete(
commonData.ResourceGroupName,
adlaAcocunt,
firewallRuleName1
);
try
{
firewallRule =
clientToUse.FirewallRules.Get(
commonData.ResourceGroupName,
adlaAcocunt,
firewallRuleName1
);
Assert.True(false, "Attempting to retrieve a deleted firewall rule did not throw.");
}
catch (CloudException e)
{
Assert.Equal(HttpStatusCode.NotFound, e.Response.StatusCode);
}
}
}
public void CreateGetUpdateDeleteTest()
{
using (var context = MockContext.Start(this.GetType().FullName))
{
commonData = new CommonTestFixture(context, true);
var clientToUse = this.GetDataLakeAnalyticsAccountManagementClient(context);
// ensure the account doesn't exist
Assert.False(clientToUse.Account.Exists(commonData.ResourceGroupName, commonData.DataLakeAnalyticsAccountName));
// Create a test account
var responseCreate =
clientToUse.Account.Create(commonData.ResourceGroupName, commonData.DataLakeAnalyticsAccountName,
parameters: new DataLakeAnalyticsAccount
{
Name = commonData.DataLakeAnalyticsAccountName,
Location = commonData.Location,
Properties = new DataLakeAnalyticsAccountProperties
{
DefaultDataLakeStoreAccount = commonData.DataLakeStoreAccountName,
DataLakeStoreAccounts = new List <DataLakeStoreAccountInfo>
{
new DataLakeStoreAccountInfo
{
Name = commonData.DataLakeStoreAccountName,
Properties = new DataLakeStoreAccountInfoProperties
{
Suffix = commonData.DataLakeStoreAccountSuffix
}
}
}
},
Tags = new Dictionary <string, string>
{
{ "testkey", "testvalue" }
}
});
// verify the account exists
Assert.True(clientToUse.Account.Exists(commonData.ResourceGroupName, commonData.DataLakeAnalyticsAccountName));
// get the account and ensure that all the values are properly set.
var responseGet = clientToUse.Account.Get(commonData.ResourceGroupName, commonData.DataLakeAnalyticsAccountName);
// validate the account creation process
Assert.True(responseGet.Properties.ProvisioningState == DataLakeAnalyticsAccountStatus.Creating || responseGet.Properties.ProvisioningState == DataLakeAnalyticsAccountStatus.Succeeded);
Assert.NotNull(responseCreate.Id);
Assert.NotNull(responseGet.Id);
Assert.Contains(commonData.DataLakeAnalyticsAccountName, responseGet.Id);
Assert.Equal(commonData.Location, responseGet.Location);
Assert.Equal(commonData.DataLakeAnalyticsAccountName, responseGet.Name);
Assert.Equal("Microsoft.DataLakeAnalytics/accounts", responseGet.Type);
Assert.True(responseGet.Properties.DataLakeStoreAccounts.Count == 1);
Assert.True(responseGet.Properties.DataLakeStoreAccounts.ToList()[0].Name.Equals(commonData.DataLakeStoreAccountName));
// wait for provisioning state to be Succeeded
// we will wait a maximum of 15 minutes for this to happen and then report failures
int timeToWaitInMinutes = 15;
int minutesWaited = 0;
while (responseGet.Properties.ProvisioningState != DataLakeAnalyticsAccountStatus.Succeeded && responseGet.Properties.ProvisioningState != DataLakeAnalyticsAccountStatus.Failed && minutesWaited <= timeToWaitInMinutes)
{
TestUtilities.Wait(60000); // Wait for one minute and then go again.
minutesWaited++;
responseGet = clientToUse.Account.Get(commonData.ResourceGroupName, commonData.DataLakeAnalyticsAccountName);
}
// Confirm that the account creation did succeed
Assert.True(responseGet.Properties.ProvisioningState == DataLakeAnalyticsAccountStatus.Succeeded);
// Update the account and confirm the updates make it in.
var newAccount = responseGet;
var firstStorageAccountName = newAccount.Properties.DataLakeStoreAccounts.ToList()[0].Name;
newAccount.Tags = new Dictionary <string, string>
{
{ "updatedKey", "updatedValue" }
};
// need to null out deep properties to prevent an error
newAccount.Properties.DataLakeStoreAccounts = null;
newAccount.Properties.StorageAccounts = null;
var updateResponse = clientToUse.Account.Update(commonData.ResourceGroupName, commonData.DataLakeAnalyticsAccountName, newAccount);
Assert.Equal(DataLakeAnalyticsAccountStatus.Succeeded, updateResponse.Properties.ProvisioningState);
// get the account and ensure that all the values are properly set.
var updateResponseGet = clientToUse.Account.Get(commonData.ResourceGroupName, commonData.DataLakeAnalyticsAccountName);
Assert.NotNull(updateResponse.Id);
Assert.Contains(responseGet.Id, updateResponseGet.Id);
Assert.Equal(responseGet.Location, updateResponseGet.Location);
Assert.Equal(newAccount.Name, updateResponseGet.Name);
Assert.Equal(responseGet.Type, updateResponseGet.Type);
// verify the new tags. NOTE: sequence equal is not ideal if we have more than 1 tag, since the ordering can change.
Assert.True(updateResponseGet.Tags.SequenceEqual(newAccount.Tags));
Assert.True(updateResponseGet.Properties.DataLakeStoreAccounts.Count == 1);
Assert.True(updateResponseGet.Properties.DataLakeStoreAccounts.ToList()[0].Name.Equals(firstStorageAccountName));
// Create another account and ensure that list account returns both
responseGet = clientToUse.Account.Get(commonData.ResourceGroupName, commonData.DataLakeAnalyticsAccountName);
var accountToChange = responseGet;
accountToChange.Name = accountToChange.Name + "secondacct";
clientToUse.Account.Create(commonData.ResourceGroupName, accountToChange.Name, accountToChange);
var listResponse = clientToUse.Account.List();
// Assert that there are at least two accounts in the list
Assert.True(listResponse.Count() > 1);
// now list with the resource group
listResponse = clientToUse.Account.ListByResourceGroup(commonData.ResourceGroupName);
// Assert that there are at least two accounts in the list
Assert.True(listResponse.Count() > 1);
// Add, list and remove a data source to the first account
// validate the data source doesn't exist first
Assert.False(clientToUse.Account.DataLakeStoreAccountExists(commonData.ResourceGroupName, commonData.DataLakeAnalyticsAccountName, commonData.SecondDataLakeStoreAccountName));
clientToUse.Account.AddDataLakeStoreAccount(commonData.ResourceGroupName,
commonData.DataLakeAnalyticsAccountName, commonData.SecondDataLakeStoreAccountName, new AddDataLakeStoreParameters {
Properties = new DataLakeStoreAccountInfoProperties {
Suffix = commonData.DataLakeStoreAccountSuffix
}
});
// verify that the store account does exist now
Assert.True(clientToUse.Account.DataLakeStoreAccountExists(commonData.ResourceGroupName, commonData.DataLakeAnalyticsAccountName, commonData.SecondDataLakeStoreAccountName));
// Get the data sources and confirm there are 2
var getDataSourceResponse =
clientToUse.Account.ListDataLakeStoreAccounts(commonData.ResourceGroupName,
commonData.DataLakeAnalyticsAccountName, null);
Assert.Equal(2, getDataSourceResponse.Count());
// get the specific data source
var getSingleDataSourceResponse =
clientToUse.Account.GetDataLakeStoreAccount(commonData.ResourceGroupName,
commonData.DataLakeAnalyticsAccountName, commonData.SecondDataLakeStoreAccountName);
Assert.Equal(commonData.SecondDataLakeStoreAccountName, getSingleDataSourceResponse.Name);
Assert.Equal(commonData.SecondDataLakeStoreAccountSuffix, getSingleDataSourceResponse.Properties.Suffix);
// Remove the data source we added
clientToUse.Account.DeleteDataLakeStoreAccount(commonData.ResourceGroupName,
commonData.DataLakeAnalyticsAccountName, commonData.SecondDataLakeStoreAccountName);
// Confirm that there is now only one data source.
getDataSourceResponse =
clientToUse.Account.ListDataLakeStoreAccounts(commonData.ResourceGroupName,
commonData.DataLakeAnalyticsAccountName, null);
Assert.Equal(1, getDataSourceResponse.Count());
// Add, list and remove an azure blob source to the first account
// verify the blob doesn't exist
Assert.False(clientToUse.Account.StorageAccountExists(commonData.ResourceGroupName, commonData.DataLakeAnalyticsAccountName, commonData.StorageAccountName));
clientToUse.Account.AddStorageAccount(commonData.ResourceGroupName,
commonData.DataLakeAnalyticsAccountName, commonData.StorageAccountName, new AddStorageAccountParameters {
Properties = new StorageAccountProperties
{
Suffix = commonData.StorageAccountSuffix,
AccessKey = commonData.StorageAccountAccessKey
}
});
// verify the blob exists now
Assert.True(clientToUse.Account.StorageAccountExists(commonData.ResourceGroupName, commonData.DataLakeAnalyticsAccountName, commonData.StorageAccountName));
// Get the data sources and confirm there is 1
var getDataSourceBlobResponse =
clientToUse.Account.ListStorageAccounts(commonData.ResourceGroupName,
commonData.DataLakeAnalyticsAccountName, null);
Assert.Equal(1, getDataSourceBlobResponse.Count());
// Get the specific data source we added and confirm that it has the same properties
var getSingleDataSourceBlobResponse =
clientToUse.Account.GetStorageAccount(commonData.ResourceGroupName,
commonData.DataLakeAnalyticsAccountName, commonData.StorageAccountName);
Assert.Equal(commonData.StorageAccountName, getSingleDataSourceBlobResponse.Name);
Assert.True(string.IsNullOrEmpty(getSingleDataSourceBlobResponse.Properties.AccessKey));
Assert.Equal(commonData.StorageAccountSuffix, getSingleDataSourceBlobResponse.Properties.Suffix);
// Remove the data source we added
clientToUse.Account.DeleteStorageAccount(commonData.ResourceGroupName,
commonData.DataLakeAnalyticsAccountName, commonData.StorageAccountName);
// Confirm that there no azure data sources.
getDataSourceBlobResponse =
clientToUse.Account.ListStorageAccounts(commonData.ResourceGroupName,
commonData.DataLakeAnalyticsAccountName, null);
Assert.Equal(0, getDataSourceBlobResponse.Count());
// Delete the account and confirm that it is deleted.
clientToUse.Account.Delete(commonData.ResourceGroupName, newAccount.Name);
// delete the account again and make sure it continues to result in a succesful code.
clientToUse.Account.Delete(commonData.ResourceGroupName, newAccount.Name);
// delete the account with its old name, which should also succeed.
clientToUse.Account.Delete(commonData.ResourceGroupName, commonData.DataLakeAnalyticsAccountName);
// delete the second account that was created to ensure that we properly clean up after ourselves.
clientToUse.Account.Delete(commonData.ResourceGroupName, accountToChange.Name);
}
}
public void AccountCRUDTest()
{
using (var context = MockContext.Start(this.GetType()))
{
commonData = new CommonTestFixture(context, true);
var clientToUse = this.GetDataLakeAnalyticsAccountManagementClient(context);
// Ensure that the account doesn't exist and that the account name is available
Assert.False(
clientToUse.Accounts.Exists(
commonData.ResourceGroupName,
commonData.DataLakeAnalyticsAccountName
)
);
var checkNameParam = new CheckNameAvailabilityParameters
{
Name = commonData.DataLakeAnalyticsAccountName
};
var responseNameCheck =
clientToUse.Accounts.CheckNameAvailability(
commonData.Location.Replace(" ", ""),
checkNameParam
);
Assert.True(responseNameCheck.NameAvailable);
// Create a test account
var responseCreate =
clientToUse.Accounts.Create(
commonData.ResourceGroupName,
commonData.DataLakeAnalyticsAccountName,
parameters: new CreateDataLakeAnalyticsAccountParameters
{
Location = commonData.Location,
Tags = new Dictionary <string, string>
{
{ "testkey", "testvalue" }
},
DefaultDataLakeStoreAccount = commonData.DataLakeStoreAccountName,
DataLakeStoreAccounts = new List <AddDataLakeStoreWithAccountParameters>
{
new AddDataLakeStoreWithAccountParameters
{
Name = commonData.DataLakeStoreAccountName,
Suffix = commonData.DataLakeStoreAccountSuffix
}
},
NewTier = TierType.Commitment100AUHours
}
);
// Verify that the account exists and that the account name is no longer available
Assert.True(
clientToUse.Accounts.Exists(
commonData.ResourceGroupName,
commonData.DataLakeAnalyticsAccountName
)
);
responseNameCheck =
clientToUse.Accounts.CheckNameAvailability(
commonData.Location.Replace(" ", ""),
checkNameParam
);
Assert.False(responseNameCheck.NameAvailable);
// Get the account and ensure that all the values are properly set.
var responseGet =
clientToUse.Accounts.Get(
commonData.ResourceGroupName,
commonData.DataLakeAnalyticsAccountName
);
// Validate the account creation process
Assert.True(responseGet.ProvisioningState == DataLakeAnalyticsAccountStatus.Creating || responseGet.ProvisioningState == DataLakeAnalyticsAccountStatus.Succeeded);
Assert.NotNull(responseCreate.Id);
Assert.NotNull(responseGet.Id);
Assert.Contains(commonData.DataLakeAnalyticsAccountName, responseGet.Id);
Assert.Equal(commonData.Location, responseGet.Location);
Assert.Equal(commonData.DataLakeAnalyticsAccountName, responseGet.Name);
Assert.Equal("Microsoft.DataLakeAnalytics/accounts", responseGet.Type);
Assert.True(responseGet.DataLakeStoreAccounts.Count == 1);
Assert.Equal(responseGet.DataLakeStoreAccounts.ToList()[0].Name, commonData.DataLakeStoreAccountName);
// Wait for provisioning state to be Succeeded
// We will wait a maximum of 15 minutes for this to happen and then report failures
int timeToWaitInMinutes = 15;
int minutesWaited = 0;
while (responseGet.ProvisioningState != DataLakeAnalyticsAccountStatus.Succeeded &&
responseGet.ProvisioningState != DataLakeAnalyticsAccountStatus.Failed &&
minutesWaited <= timeToWaitInMinutes)
{
TestUtilities.Wait(60000); // Wait for one minute and then go again.
minutesWaited++;
responseGet =
clientToUse.Accounts.Get(
commonData.ResourceGroupName,
commonData.DataLakeAnalyticsAccountName
);
}
// Confirm that the account creation did succeed
Assert.True(responseGet.ProvisioningState == DataLakeAnalyticsAccountStatus.Succeeded);
Assert.Equal(TierType.Commitment100AUHours, responseGet.CurrentTier);
Assert.Equal(TierType.Commitment100AUHours, responseGet.NewTier);
// Update the account and confirm that the updates make it in.
var responseUpdate =
clientToUse.Accounts.Update(
commonData.ResourceGroupName,
commonData.DataLakeAnalyticsAccountName,
parameters: new UpdateDataLakeAnalyticsAccountParameters
{
Tags = new Dictionary <string, string>
{
{ "updatedKey", "updatedValue" }
},
NewTier = TierType.Consumption
}
);
Assert.Equal(DataLakeAnalyticsAccountStatus.Succeeded, responseUpdate.ProvisioningState);
// Get the account and ensure that all the values are properly set.
var responseUpdateGet =
clientToUse.Accounts.Get(
commonData.ResourceGroupName,
commonData.DataLakeAnalyticsAccountName
);
Assert.NotNull(responseUpdate.Id);
Assert.Contains(responseGet.Id, responseUpdateGet.Id);
Assert.Equal(responseGet.Location, responseUpdateGet.Location);
Assert.Equal(responseGet.Name, responseUpdateGet.Name);
Assert.Equal(responseGet.Type, responseUpdateGet.Type);
// Verify the new tags and tier
Assert.True(responseUpdateGet.Tags.Count == 1);
Assert.True(responseUpdateGet.Tags.ContainsKey("updatedKey"));
Assert.True(responseUpdateGet.Tags.Values.Contains("updatedValue"));
Assert.Equal(TierType.Commitment100AUHours, responseUpdateGet.CurrentTier);
Assert.Equal(TierType.Consumption, responseUpdateGet.NewTier);
// Create another account and ensure that list account returns both
clientToUse.Accounts.Create(
commonData.ResourceGroupName,
commonData.DataLakeAnalyticsAccountName + "secondacct",
new CreateDataLakeAnalyticsAccountParameters
{
Location = commonData.Location,
DefaultDataLakeStoreAccount = commonData.DataLakeStoreAccountName,
DataLakeStoreAccounts = new List <AddDataLakeStoreWithAccountParameters>
{
new AddDataLakeStoreWithAccountParameters
{
Name = commonData.DataLakeStoreAccountName,
Suffix = commonData.DataLakeStoreAccountSuffix
}
},
}
);
var listResponse = clientToUse.Accounts.List();
// Assert that there are at least two accounts in the list
Assert.True(listResponse.Count() > 1);
// Now list with the resource group
listResponse = clientToUse.Accounts.ListByResourceGroup(commonData.ResourceGroupName);
// Assert that there are at least two accounts in the list
Assert.True(listResponse.Count() > 1);
// Add, list and remove a data source to the first account
// Validate the data source doesn't exist first
Assert.False(
clientToUse.Accounts.DataLakeStoreAccountExists(
commonData.ResourceGroupName,
commonData.DataLakeAnalyticsAccountName,
commonData.SecondDataLakeStoreAccountName
)
);
clientToUse.DataLakeStoreAccounts.Add(
commonData.ResourceGroupName,
commonData.DataLakeAnalyticsAccountName,
commonData.SecondDataLakeStoreAccountName,
new AddDataLakeStoreParameters
{
Suffix = commonData.DataLakeStoreAccountSuffix
}
);
// Verify that the store account does exist now
Assert.True(
clientToUse.Accounts.DataLakeStoreAccountExists(
commonData.ResourceGroupName,
commonData.DataLakeAnalyticsAccountName,
commonData.SecondDataLakeStoreAccountName
)
);
// Get the data sources and confirm there are 2
var getDataSourceResponse =
clientToUse.DataLakeStoreAccounts.ListByAccount(
commonData.ResourceGroupName,
commonData.DataLakeAnalyticsAccountName
);
Assert.Equal(2, getDataSourceResponse.Count());
// Get the specific data source
var getSingleDataSourceResponse =
clientToUse.DataLakeStoreAccounts.Get(
commonData.ResourceGroupName,
commonData.DataLakeAnalyticsAccountName,
commonData.SecondDataLakeStoreAccountName
);
Assert.Equal(commonData.SecondDataLakeStoreAccountName, getSingleDataSourceResponse.Name);
Assert.Equal(commonData.SecondDataLakeStoreAccountSuffix, getSingleDataSourceResponse.Suffix);
// Remove the data source we added
clientToUse.DataLakeStoreAccounts.Delete(
commonData.ResourceGroupName,
commonData.DataLakeAnalyticsAccountName,
commonData.SecondDataLakeStoreAccountName
);
// Confirm that there is now only one data source.
getDataSourceResponse =
clientToUse.DataLakeStoreAccounts.ListByAccount(
commonData.ResourceGroupName,
commonData.DataLakeAnalyticsAccountName
);
Assert.True(getDataSourceResponse.Count() == 1);
// Add, list and remove an azure blob source to the first account
// Verify the blob doesn't exist
Assert.False(
clientToUse.Accounts.StorageAccountExists(
commonData.ResourceGroupName,
commonData.DataLakeAnalyticsAccountName,
commonData.StorageAccountName
)
);
clientToUse.StorageAccounts.Add(
commonData.ResourceGroupName,
commonData.DataLakeAnalyticsAccountName,
commonData.StorageAccountName,
new AddStorageAccountParameters
{
Suffix = commonData.StorageAccountSuffix,
AccessKey = commonData.StorageAccountAccessKey
}
);
// Verify the blob exists now
Assert.True(
clientToUse.Accounts.StorageAccountExists(
commonData.ResourceGroupName,
commonData.DataLakeAnalyticsAccountName,
commonData.StorageAccountName
)
);
// Get the data sources and confirm there is 1
var getDataSourceBlobResponse =
clientToUse.StorageAccounts.ListByAccount(
commonData.ResourceGroupName,
commonData.DataLakeAnalyticsAccountName
);
Assert.True(getDataSourceBlobResponse.Count() == 1);
// Get the specific data source we added and confirm that it has the same properties
var getSingleDataSourceBlobResponse =
clientToUse.StorageAccounts.Get(
commonData.ResourceGroupName,
commonData.DataLakeAnalyticsAccountName,
commonData.StorageAccountName
);
Assert.Equal(commonData.StorageAccountName, getSingleDataSourceBlobResponse.Name);
Assert.Equal(commonData.StorageAccountSuffix, getSingleDataSourceBlobResponse.Suffix);
// Remove the data source we added
clientToUse.StorageAccounts.Delete(
commonData.ResourceGroupName,
commonData.DataLakeAnalyticsAccountName,
commonData.StorageAccountName
);
// Confirm that there no azure data sources.
getDataSourceBlobResponse =
clientToUse.StorageAccounts.ListByAccount(
commonData.ResourceGroupName,
commonData.DataLakeAnalyticsAccountName
);
Assert.True(getDataSourceBlobResponse.Count() == 0);
// Check that Locations_GetCapability and Operations_List are functional
var responseGetCapability =
clientToUse.Locations.GetCapability(
commonData.Location.Replace(" ", "")
);
Assert.NotNull(responseGetCapability);
var responseListOps = clientToUse.Operations.List();
Assert.NotNull(responseListOps);
// Delete the account and confirm that it is deleted.
clientToUse.Accounts.Delete(
commonData.ResourceGroupName,
commonData.DataLakeAnalyticsAccountName + "secondacct"
);
// Delete the account again and make sure it continues to result in a successful code.
clientToUse.Accounts.Delete(
commonData.ResourceGroupName,
commonData.DataLakeAnalyticsAccountName + "secondacct"
);
// Delete the account with its old name, which should also succeed.
clientToUse.Accounts.Delete(
commonData.ResourceGroupName,
commonData.DataLakeAnalyticsAccountName
);
}
}
public void ComputePolicyCRUDTest()
{
using (var context = MockContext.Start(this.GetType()))
{
commonData = new CommonTestFixture(context, true);
var clientToUse = this.GetDataLakeAnalyticsAccountManagementClient(context);
var userPolicyObjectId = new Guid("8ce05900-7a9e-4895-b3f0-0fbcee507803");
var userPolicyName = TestUtilities.GenerateName("adlapolicy1");
var groupPolicyObjectId = new Guid("0583cfd7-60f5-43f0-9597-68b85591fc69");
var groupPolicyName = TestUtilities.GenerateName("adlapolicy2");
var adlaAccountName = TestUtilities.GenerateName("adlaacct1");
// Ensure the account doesn't exist
Assert.False(
clientToUse.Accounts.Exists(
commonData.ResourceGroupName,
adlaAccountName
)
);
// Create a test account
var responseCreate =
clientToUse.Accounts.Create(
commonData.ResourceGroupName,
adlaAccountName,
parameters: new CreateDataLakeAnalyticsAccountParameters
{
Location = commonData.Location,
DefaultDataLakeStoreAccount = commonData.DataLakeStoreAccountName,
DataLakeStoreAccounts = new List <AddDataLakeStoreWithAccountParameters>
{
new AddDataLakeStoreWithAccountParameters
{
Name = commonData.DataLakeStoreAccountName,
Suffix = commonData.DataLakeStoreAccountSuffix
}
},
NewTier = TierType.Commitment100AUHours,
ComputePolicies = new List <CreateComputePolicyWithAccountParameters>
{
new CreateComputePolicyWithAccountParameters
{
Name = userPolicyName,
ObjectId = userPolicyObjectId,
ObjectType = AADObjectType.User,
MaxDegreeOfParallelismPerJob = 1,
MinPriorityPerJob = 1,
}
}
}
);
// Get the account and ensure that all the values are properly set.
var responseGet =
clientToUse.Accounts.Get(
commonData.ResourceGroupName,
adlaAccountName
);
// Validate compute policies are set on creation.
Assert.True(responseGet.ComputePolicies.Count == 1);
Assert.Equal(responseGet.ComputePolicies.ToList()[0].Name, userPolicyName);
// Validate compute policy CRUD
// Add another account
var computePolicy =
clientToUse.ComputePolicies.CreateOrUpdate(
commonData.ResourceGroupName,
adlaAccountName,
groupPolicyName,
new CreateOrUpdateComputePolicyParameters
{
ObjectId = groupPolicyObjectId,
ObjectType = AADObjectType.Group,
MaxDegreeOfParallelismPerJob = 1,
MinPriorityPerJob = 1,
}
);
Assert.Equal(1, computePolicy.MaxDegreeOfParallelismPerJob);
Assert.Equal(1, computePolicy.MinPriorityPerJob);
Assert.Equal(groupPolicyObjectId, computePolicy.ObjectId);
Assert.Equal(AADObjectType.Group, computePolicy.ObjectType);
// Get the compute policy
computePolicy =
clientToUse.ComputePolicies.Get(
commonData.ResourceGroupName,
adlaAccountName,
groupPolicyName
);
Assert.Equal(1, computePolicy.MaxDegreeOfParallelismPerJob);
Assert.Equal(1, computePolicy.MinPriorityPerJob);
Assert.Equal(groupPolicyObjectId, computePolicy.ObjectId);
Assert.Equal(AADObjectType.Group, computePolicy.ObjectType);
// List all policies
var policyList =
clientToUse.ComputePolicies.ListByAccount(
commonData.ResourceGroupName,
adlaAccountName
);
Assert.Equal(2, policyList.Count());
// Remove the new policy
clientToUse.ComputePolicies.Delete(
commonData.ResourceGroupName,
adlaAccountName,
groupPolicyName
);
policyList =
clientToUse.ComputePolicies.ListByAccount(
commonData.ResourceGroupName,
adlaAccountName
);
Assert.True(policyList.Count() == 1);
// Delete the account
clientToUse.Accounts.Delete(commonData.ResourceGroupName, adlaAccountName);
}
}
public void CreateGetUpdateDeleteTest()
{
TestUtilities.StartTest();
try
{
UndoContext.Current.Start();
CommonTestFixture commonData = new CommonTestFixture();
var clientToUse = this.GetDataLakeAnalyticsManagementClient();
// Create a test account
AzureAsyncOperationResponse responseCreate =
clientToUse.DataLakeAnalyticsAccount.Create(commonData.ResourceGroupName,
parameters: new DataLakeAnalyticsAccountCreateOrUpdateParameters
{
DataLakeAnalyticsAccount = new DataLakeAnalyticsAccount
{
Name = commonData.DataLakeAnalyticsAccountName,
Location = commonData.Location,
Properties = new DataLakeAnalyticsAccountProperties
{
DefaultDataLakeStoreAccount = commonData.DataLakeStoreAccountName,
DataLakeStoreAccounts = new List<DataLakeStoreAccount>
{
new DataLakeStoreAccount
{
Name = commonData.DataLakeStoreAccountName,
Properties = new DataLakeStoreAccountProperties
{
Suffix = commonData.DataLakeStoreAccountSuffix
}
}
}
},
Tags = new Dictionary<string, string>
{
{ "testkey","testvalue" }
}
}
});
Assert.Equal(HttpStatusCode.OK, responseCreate.StatusCode);
// get the account and ensure that all the values are properly set.
var responseGet = clientToUse.DataLakeAnalyticsAccount.Get(commonData.ResourceGroupName, commonData.DataLakeAnalyticsAccountName);
// validate the account creation process
Assert.True(responseGet.DataLakeAnalyticsAccount.Properties.ProvisioningState == DataLakeAnalyticsAccountStatus.Creating || responseGet.DataLakeAnalyticsAccount.Properties.ProvisioningState == DataLakeAnalyticsAccountStatus.Succeeded);
Assert.NotNull(responseCreate.RequestId);
Assert.NotNull(responseGet.RequestId);
Assert.Contains(commonData.DataLakeAnalyticsAccountName, responseGet.DataLakeAnalyticsAccount.Id);
Assert.Equal(commonData.Location, responseGet.DataLakeAnalyticsAccount.Location);
Assert.Equal(commonData.DataLakeAnalyticsAccountName, responseGet.DataLakeAnalyticsAccount.Name);
Assert.Equal("Microsoft.DataLakeAnalytics/accounts", responseGet.DataLakeAnalyticsAccount.Type);
Assert.True(responseGet.DataLakeAnalyticsAccount.Properties.DataLakeStoreAccounts.Count == 1);
Assert.True(responseGet.DataLakeAnalyticsAccount.Properties.DataLakeStoreAccounts.ToList()[0].Name.Equals(commonData.DataLakeStoreAccountName));
// wait for provisioning state to be Succeeded
// we will wait a maximum of 15 minutes for this to happen and then report failures
int timeToWaitInMinutes = 15;
int minutesWaited = 0;
while (responseGet.DataLakeAnalyticsAccount.Properties.ProvisioningState != DataLakeAnalyticsAccountStatus.Succeeded && responseGet.DataLakeAnalyticsAccount.Properties.ProvisioningState != DataLakeAnalyticsAccountStatus.Failed && minutesWaited <= timeToWaitInMinutes)
{
TestUtilities.Wait(60000); // Wait for one minute and then go again.
minutesWaited++;
responseGet = clientToUse.DataLakeAnalyticsAccount.Get(commonData.ResourceGroupName, commonData.DataLakeAnalyticsAccountName);
}
// Confirm that the account creation did succeed
Assert.True(responseGet.DataLakeAnalyticsAccount.Properties.ProvisioningState == DataLakeAnalyticsAccountStatus.Succeeded);
// Update the account and confirm the updates make it in.
var newAccount = responseGet.DataLakeAnalyticsAccount;
var firstStorageAccountName = newAccount.Properties.DataLakeStoreAccounts.ToList()[0].Name;
newAccount.Tags = new Dictionary<string, string>
{
{"updatedKey", "updatedValue"}
};
// need to null out deep properties to prevent an error
newAccount.Properties.DataLakeStoreAccounts = null;
newAccount.Properties.StorageAccounts = null;
var updateResponse = clientToUse.DataLakeAnalyticsAccount.Update(commonData.ResourceGroupName, new DataLakeAnalyticsAccountCreateOrUpdateParameters
{
DataLakeAnalyticsAccount = newAccount,
});
Assert.Equal(HttpStatusCode.OK, updateResponse.StatusCode);
Assert.Equal(updateResponse.Status, OperationStatus.Succeeded);
// get the account and ensure that all the values are properly set.
var updateResponseGet = clientToUse.DataLakeAnalyticsAccount.Get(commonData.ResourceGroupName, commonData.DataLakeAnalyticsAccountName);
Assert.NotNull(updateResponse.RequestId);
Assert.Contains(responseGet.DataLakeAnalyticsAccount.Id, updateResponseGet.DataLakeAnalyticsAccount.Id);
Assert.Equal(responseGet.DataLakeAnalyticsAccount.Location, updateResponseGet.DataLakeAnalyticsAccount.Location);
Assert.Equal(newAccount.Name, updateResponseGet.DataLakeAnalyticsAccount.Name);
Assert.Equal(responseGet.DataLakeAnalyticsAccount.Type, updateResponseGet.DataLakeAnalyticsAccount.Type);
// verify the new tags. NOTE: sequence equal is not ideal if we have more than 1 tag, since the ordering can change.
Assert.True(updateResponseGet.DataLakeAnalyticsAccount.Tags.SequenceEqual(newAccount.Tags));
Assert.True(updateResponseGet.DataLakeAnalyticsAccount.Properties.DataLakeStoreAccounts.Count == 1);
Assert.True(updateResponseGet.DataLakeAnalyticsAccount.Properties.DataLakeStoreAccounts.ToList()[0].Name.Equals(firstStorageAccountName));
// Create another account and ensure that list account returns both
var accountToChange = responseGet.DataLakeAnalyticsAccount;
accountToChange.Name = accountToChange.Name + "secondacct";
var parameters = new DataLakeAnalyticsAccountCreateOrUpdateParameters
{
DataLakeAnalyticsAccount = accountToChange
};
clientToUse.DataLakeAnalyticsAccount.Create(commonData.ResourceGroupName, parameters);
DataLakeAnalyticsAccountListResponse listResponse = clientToUse.DataLakeAnalyticsAccount.List(commonData.ResourceGroupName, null);
// Assert that there are at least two accounts in the list
Assert.True(listResponse.Value.Count > 1);
// Add, list and remove a data source to the first account
var addDataSourceResponse =
clientToUse.DataLakeAnalyticsAccount.AddDataLakeStoreAccount(commonData.ResourceGroupName,
commonData.DataLakeAnalyticsAccountName, commonData.SecondDataLakeStoreAccountName,
new AddDataLakeStoreParameters
{
Properties =
new DataLakeStoreAccountProperties {Suffix = commonData.DataLakeStoreAccountSuffix}
});
Assert.Equal(HttpStatusCode.OK, addDataSourceResponse.StatusCode);
// Get the data sources and confirm there are 2
var getDataSourceResponse =
clientToUse.DataLakeAnalyticsAccount.ListDataLakeStoreAccounts(commonData.ResourceGroupName,
commonData.DataLakeAnalyticsAccountName, null);
Assert.Equal(HttpStatusCode.OK, getDataSourceResponse.StatusCode);
Assert.Equal(2, getDataSourceResponse.Value.Count);
// get the specific data source
var getSingleDataSourceResponse =
clientToUse.DataLakeAnalyticsAccount.GetDataLakeStoreAccount(commonData.ResourceGroupName,
commonData.DataLakeAnalyticsAccountName, commonData.SecondDataLakeStoreAccountName);
Assert.Equal(HttpStatusCode.OK, getSingleDataSourceResponse.StatusCode);
Assert.Equal(commonData.SecondDataLakeStoreAccountName, getSingleDataSourceResponse.DataLakeStoreAccount.Name);
Assert.Equal(commonData.SecondDataLakeStoreAccountSuffix, getSingleDataSourceResponse.DataLakeStoreAccount.Properties.Suffix);
// Remove the data source we added
var removeDataSourceResponse =
clientToUse.DataLakeAnalyticsAccount.DeleteDataLakeStoreAccount(commonData.ResourceGroupName,
commonData.DataLakeAnalyticsAccountName, commonData.SecondDataLakeStoreAccountName);
Assert.Equal(HttpStatusCode.OK, removeDataSourceResponse.StatusCode);
// Confirm that there is now only one data source.
getDataSourceResponse =
clientToUse.DataLakeAnalyticsAccount.ListDataLakeStoreAccounts(commonData.ResourceGroupName,
commonData.DataLakeAnalyticsAccountName, null);
Assert.Equal(HttpStatusCode.OK, getDataSourceResponse.StatusCode);
Assert.Equal(1, getDataSourceResponse.Value.Count);
// Add, list and remove an azure blob source to the first account
var addDataSourceBlobResponse =
clientToUse.DataLakeAnalyticsAccount.AddStorageAccount(commonData.ResourceGroupName,
commonData.DataLakeAnalyticsAccountName, commonData.StorageAccountName,
new AddStorageAccountParameters
{
Properties =
new StorageAccountProperties
{
Suffix = commonData.StorageAccountSuffix,
AccessKey = commonData.StorageAccountAccessKey
}
});
Assert.Equal(HttpStatusCode.OK, addDataSourceBlobResponse.StatusCode);
// Get the data sources and confirm there is 1
var getDataSourceBlobResponse =
clientToUse.DataLakeAnalyticsAccount.ListStorageAccounts(commonData.ResourceGroupName,
commonData.DataLakeAnalyticsAccountName, null);
Assert.Equal(HttpStatusCode.OK, getDataSourceBlobResponse.StatusCode);
Assert.Equal(1, getDataSourceBlobResponse.Value.Count);
// Get the specific data source we added and confirm that it has the same properties
var getSingleDataSourceBlobResponse =
clientToUse.DataLakeAnalyticsAccount.GetStorageAccount(commonData.ResourceGroupName,
commonData.DataLakeAnalyticsAccountName, commonData.StorageAccountName);
Assert.Equal(HttpStatusCode.OK, getSingleDataSourceBlobResponse.StatusCode);
Assert.Equal(commonData.StorageAccountName, getSingleDataSourceBlobResponse.StorageAccount.Name);
Assert.True(string.IsNullOrEmpty(getSingleDataSourceBlobResponse.StorageAccount.Properties.AccessKey));
Assert.Equal(commonData.StorageAccountSuffix, getSingleDataSourceBlobResponse.StorageAccount.Properties.Suffix);
// Remove the data source we added
var removeDataSourceBlobResponse =
clientToUse.DataLakeAnalyticsAccount.DeleteStorageAccount(commonData.ResourceGroupName,
commonData.DataLakeAnalyticsAccountName, commonData.StorageAccountName);
Assert.Equal(HttpStatusCode.OK, removeDataSourceBlobResponse.StatusCode);
// Confirm that there no azure data sources.
getDataSourceBlobResponse =
clientToUse.DataLakeAnalyticsAccount.ListStorageAccounts(commonData.ResourceGroupName,
commonData.DataLakeAnalyticsAccountName, null);
Assert.Equal(HttpStatusCode.OK, getDataSourceResponse.StatusCode);
Assert.Equal(0, getDataSourceBlobResponse.Value.Count);
// Delete the account and confirm that it is deleted.
AzureOperationResponse deleteResponse = clientToUse.DataLakeAnalyticsAccount.Delete(commonData.ResourceGroupName, newAccount.Name);
// define the list of accepted status codes when deleting an account.
List<HttpStatusCode> acceptedStatusCodes = new List<HttpStatusCode>
{
HttpStatusCode.OK,
HttpStatusCode.Accepted,
HttpStatusCode.NotFound,
HttpStatusCode.NoContent
};
Assert.Contains<HttpStatusCode>(deleteResponse.StatusCode, acceptedStatusCodes);
Assert.NotNull(deleteResponse.RequestId);
// delete the account again and make sure it continues to result in a succesful code.
deleteResponse = clientToUse.DataLakeAnalyticsAccount.Delete(commonData.ResourceGroupName, newAccount.Name);
Assert.Contains<HttpStatusCode>(deleteResponse.StatusCode, acceptedStatusCodes);
// delete the account with its old name, which should also succeed.
deleteResponse = clientToUse.DataLakeAnalyticsAccount.Delete(commonData.ResourceGroupName, commonData.DataLakeAnalyticsAccountName);
Assert.Contains<HttpStatusCode>(deleteResponse.StatusCode, acceptedStatusCodes);
// delete the second account that was created to ensure that we properly clean up after ourselves.
deleteResponse = clientToUse.DataLakeAnalyticsAccount.Delete(commonData.ResourceGroupName, accountToChange.Name);
Assert.Contains<HttpStatusCode>(deleteResponse.StatusCode, acceptedStatusCodes);
}
finally
{
// we don't catch any exceptions, those should all be bubbled up.
UndoContext.Current.UndoAll();
TestUtilities.EndTest();
}
}
public void CreateGetUpdateDeleteTest()
{
TestUtilities.StartTest();
try
{
UndoContext.Current.Start();
CommonTestFixture commonData = new CommonTestFixture();
var clientToUse = this.GetDataLakeAnalyticsManagementClient();
// Create a test account
AzureAsyncOperationResponse responseCreate =
clientToUse.DataLakeAnalyticsAccount.Create(commonData.ResourceGroupName,
parameters: new DataLakeAnalyticsAccountCreateOrUpdateParameters
{
DataLakeAnalyticsAccount = new DataLakeAnalyticsAccount
{
Name = commonData.DataLakeAnalyticsAccountName,
Location = commonData.Location,
Properties = new DataLakeAnalyticsAccountProperties
{
DefaultDataLakeStoreAccount = commonData.DataLakeStoreAccountName,
DataLakeStoreAccounts = new List <DataLakeStoreAccount>
{
new DataLakeStoreAccount
{
Name = commonData.DataLakeStoreAccountName,
Properties = new DataLakeStoreAccountProperties
{
Suffix = commonData.DataLakeStoreAccountSuffix
}
}
}
},
Tags = new Dictionary <string, string>
{
{ "testkey", "testvalue" }
}
}
});
Assert.Equal(HttpStatusCode.OK, responseCreate.StatusCode);
// get the account and ensure that all the values are properly set.
var responseGet = clientToUse.DataLakeAnalyticsAccount.Get(commonData.ResourceGroupName, commonData.DataLakeAnalyticsAccountName);
// validate the account creation process
Assert.True(responseGet.DataLakeAnalyticsAccount.Properties.ProvisioningState == DataLakeAnalyticsAccountStatus.Creating || responseGet.DataLakeAnalyticsAccount.Properties.ProvisioningState == DataLakeAnalyticsAccountStatus.Succeeded);
Assert.NotNull(responseCreate.RequestId);
Assert.NotNull(responseGet.RequestId);
Assert.Contains(commonData.DataLakeAnalyticsAccountName, responseGet.DataLakeAnalyticsAccount.Id);
Assert.Equal(commonData.Location, responseGet.DataLakeAnalyticsAccount.Location);
Assert.Equal(commonData.DataLakeAnalyticsAccountName, responseGet.DataLakeAnalyticsAccount.Name);
Assert.Equal("Microsoft.DataLakeAnalytics/accounts", responseGet.DataLakeAnalyticsAccount.Type);
Assert.True(responseGet.DataLakeAnalyticsAccount.Properties.DataLakeStoreAccounts.Count == 1);
Assert.True(responseGet.DataLakeAnalyticsAccount.Properties.DataLakeStoreAccounts.ToList()[0].Name.Equals(commonData.DataLakeStoreAccountName));
// wait for provisioning state to be Succeeded
// we will wait a maximum of 15 minutes for this to happen and then report failures
int timeToWaitInMinutes = 15;
int minutesWaited = 0;
while (responseGet.DataLakeAnalyticsAccount.Properties.ProvisioningState != DataLakeAnalyticsAccountStatus.Succeeded && responseGet.DataLakeAnalyticsAccount.Properties.ProvisioningState != DataLakeAnalyticsAccountStatus.Failed && minutesWaited <= timeToWaitInMinutes)
{
TestUtilities.Wait(60000); // Wait for one minute and then go again.
minutesWaited++;
responseGet = clientToUse.DataLakeAnalyticsAccount.Get(commonData.ResourceGroupName, commonData.DataLakeAnalyticsAccountName);
}
// Confirm that the account creation did succeed
Assert.True(responseGet.DataLakeAnalyticsAccount.Properties.ProvisioningState == DataLakeAnalyticsAccountStatus.Succeeded);
// Update the account and confirm the updates make it in.
var newAccount = responseGet.DataLakeAnalyticsAccount;
var firstStorageAccountName = newAccount.Properties.DataLakeStoreAccounts.ToList()[0].Name;
newAccount.Tags = new Dictionary <string, string>
{
{ "updatedKey", "updatedValue" }
};
// need to null out deep properties to prevent an error
newAccount.Properties.DataLakeStoreAccounts = null;
newAccount.Properties.StorageAccounts = null;
var updateResponse = clientToUse.DataLakeAnalyticsAccount.Update(commonData.ResourceGroupName, new DataLakeAnalyticsAccountCreateOrUpdateParameters
{
DataLakeAnalyticsAccount = newAccount,
});
Assert.Equal(HttpStatusCode.OK, updateResponse.StatusCode);
Assert.Equal(updateResponse.Status, OperationStatus.Succeeded);
// get the account and ensure that all the values are properly set.
var updateResponseGet = clientToUse.DataLakeAnalyticsAccount.Get(commonData.ResourceGroupName, commonData.DataLakeAnalyticsAccountName);
Assert.NotNull(updateResponse.RequestId);
Assert.Contains(responseGet.DataLakeAnalyticsAccount.Id, updateResponseGet.DataLakeAnalyticsAccount.Id);
Assert.Equal(responseGet.DataLakeAnalyticsAccount.Location, updateResponseGet.DataLakeAnalyticsAccount.Location);
Assert.Equal(newAccount.Name, updateResponseGet.DataLakeAnalyticsAccount.Name);
Assert.Equal(responseGet.DataLakeAnalyticsAccount.Type, updateResponseGet.DataLakeAnalyticsAccount.Type);
// verify the new tags. NOTE: sequence equal is not ideal if we have more than 1 tag, since the ordering can change.
Assert.True(updateResponseGet.DataLakeAnalyticsAccount.Tags.SequenceEqual(newAccount.Tags));
Assert.True(updateResponseGet.DataLakeAnalyticsAccount.Properties.DataLakeStoreAccounts.Count == 1);
Assert.True(updateResponseGet.DataLakeAnalyticsAccount.Properties.DataLakeStoreAccounts.ToList()[0].Name.Equals(firstStorageAccountName));
// Create another account and ensure that list account returns both
var accountToChange = responseGet.DataLakeAnalyticsAccount;
accountToChange.Name = accountToChange.Name + "secondacct";
var parameters = new DataLakeAnalyticsAccountCreateOrUpdateParameters
{
DataLakeAnalyticsAccount = accountToChange
};
clientToUse.DataLakeAnalyticsAccount.Create(commonData.ResourceGroupName, parameters);
DataLakeAnalyticsAccountListResponse listResponse = clientToUse.DataLakeAnalyticsAccount.List(commonData.ResourceGroupName, null);
// Assert that there are at least two accounts in the list
Assert.True(listResponse.Value.Count > 1);
// Add, list and remove a data source to the first account
var addDataSourceResponse =
clientToUse.DataLakeAnalyticsAccount.AddDataLakeStoreAccount(commonData.ResourceGroupName,
commonData.DataLakeAnalyticsAccountName, commonData.SecondDataLakeStoreAccountName,
new AddDataLakeStoreParameters
{
Properties =
new DataLakeStoreAccountProperties {
Suffix = commonData.DataLakeStoreAccountSuffix
}
});
Assert.Equal(HttpStatusCode.OK, addDataSourceResponse.StatusCode);
// Get the data sources and confirm there are 2
var getDataSourceResponse =
clientToUse.DataLakeAnalyticsAccount.ListDataLakeStoreAccounts(commonData.ResourceGroupName,
commonData.DataLakeAnalyticsAccountName, null);
Assert.Equal(HttpStatusCode.OK, getDataSourceResponse.StatusCode);
Assert.Equal(2, getDataSourceResponse.Value.Count);
// get the specific data source
var getSingleDataSourceResponse =
clientToUse.DataLakeAnalyticsAccount.GetDataLakeStoreAccount(commonData.ResourceGroupName,
commonData.DataLakeAnalyticsAccountName, commonData.SecondDataLakeStoreAccountName);
Assert.Equal(HttpStatusCode.OK, getSingleDataSourceResponse.StatusCode);
Assert.Equal(commonData.SecondDataLakeStoreAccountName, getSingleDataSourceResponse.DataLakeStoreAccount.Name);
Assert.Equal(commonData.SecondDataLakeStoreAccountSuffix, getSingleDataSourceResponse.DataLakeStoreAccount.Properties.Suffix);
// Remove the data source we added
var removeDataSourceResponse =
clientToUse.DataLakeAnalyticsAccount.DeleteDataLakeStoreAccount(commonData.ResourceGroupName,
commonData.DataLakeAnalyticsAccountName, commonData.SecondDataLakeStoreAccountName);
Assert.Equal(HttpStatusCode.OK, removeDataSourceResponse.StatusCode);
// Confirm that there is now only one data source.
getDataSourceResponse =
clientToUse.DataLakeAnalyticsAccount.ListDataLakeStoreAccounts(commonData.ResourceGroupName,
commonData.DataLakeAnalyticsAccountName, null);
Assert.Equal(HttpStatusCode.OK, getDataSourceResponse.StatusCode);
Assert.Equal(1, getDataSourceResponse.Value.Count);
// Add, list and remove an azure blob source to the first account
var addDataSourceBlobResponse =
clientToUse.DataLakeAnalyticsAccount.AddStorageAccount(commonData.ResourceGroupName,
commonData.DataLakeAnalyticsAccountName, commonData.StorageAccountName,
new AddStorageAccountParameters
{
Properties =
new StorageAccountProperties
{
Suffix = commonData.StorageAccountSuffix,
AccessKey = commonData.StorageAccountAccessKey
}
});
Assert.Equal(HttpStatusCode.OK, addDataSourceBlobResponse.StatusCode);
// Get the data sources and confirm there is 1
var getDataSourceBlobResponse =
clientToUse.DataLakeAnalyticsAccount.ListStorageAccounts(commonData.ResourceGroupName,
commonData.DataLakeAnalyticsAccountName, null);
Assert.Equal(HttpStatusCode.OK, getDataSourceBlobResponse.StatusCode);
Assert.Equal(1, getDataSourceBlobResponse.Value.Count);
// Get the specific data source we added and confirm that it has the same properties
var getSingleDataSourceBlobResponse =
clientToUse.DataLakeAnalyticsAccount.GetStorageAccount(commonData.ResourceGroupName,
commonData.DataLakeAnalyticsAccountName, commonData.StorageAccountName);
Assert.Equal(HttpStatusCode.OK, getSingleDataSourceBlobResponse.StatusCode);
Assert.Equal(commonData.StorageAccountName, getSingleDataSourceBlobResponse.StorageAccount.Name);
Assert.True(string.IsNullOrEmpty(getSingleDataSourceBlobResponse.StorageAccount.Properties.AccessKey));
Assert.Equal(commonData.StorageAccountSuffix, getSingleDataSourceBlobResponse.StorageAccount.Properties.Suffix);
// Remove the data source we added
var removeDataSourceBlobResponse =
clientToUse.DataLakeAnalyticsAccount.DeleteStorageAccount(commonData.ResourceGroupName,
commonData.DataLakeAnalyticsAccountName, commonData.StorageAccountName);
Assert.Equal(HttpStatusCode.OK, removeDataSourceBlobResponse.StatusCode);
// Confirm that there no azure data sources.
getDataSourceBlobResponse =
clientToUse.DataLakeAnalyticsAccount.ListStorageAccounts(commonData.ResourceGroupName,
commonData.DataLakeAnalyticsAccountName, null);
Assert.Equal(HttpStatusCode.OK, getDataSourceResponse.StatusCode);
Assert.Equal(0, getDataSourceBlobResponse.Value.Count);
// Delete the account and confirm that it is deleted.
AzureOperationResponse deleteResponse = clientToUse.DataLakeAnalyticsAccount.Delete(commonData.ResourceGroupName, newAccount.Name);
// define the list of accepted status codes when deleting an account.
List <HttpStatusCode> acceptedStatusCodes = new List <HttpStatusCode>
{
HttpStatusCode.OK,
HttpStatusCode.Accepted,
HttpStatusCode.NotFound,
HttpStatusCode.NoContent
};
Assert.Contains <HttpStatusCode>(deleteResponse.StatusCode, acceptedStatusCodes);
Assert.NotNull(deleteResponse.RequestId);
// delete the account again and make sure it continues to result in a succesful code.
deleteResponse = clientToUse.DataLakeAnalyticsAccount.Delete(commonData.ResourceGroupName, newAccount.Name);
Assert.Contains <HttpStatusCode>(deleteResponse.StatusCode, acceptedStatusCodes);
// delete the account with its old name, which should also succeed.
deleteResponse = clientToUse.DataLakeAnalyticsAccount.Delete(commonData.ResourceGroupName, commonData.DataLakeAnalyticsAccountName);
Assert.Contains <HttpStatusCode>(deleteResponse.StatusCode, acceptedStatusCodes);
// delete the second account that was created to ensure that we properly clean up after ourselves.
deleteResponse = clientToUse.DataLakeAnalyticsAccount.Delete(commonData.ResourceGroupName, accountToChange.Name);
Assert.Contains <HttpStatusCode>(deleteResponse.StatusCode, acceptedStatusCodes);
}
finally
{
// we don't catch any exceptions, those should all be bubbled up.
UndoContext.Current.UndoAll();
TestUtilities.EndTest();
}
}
public void CredentialCRUDTest()
{
using (var context = MockContext.Start(this.GetType().FullName))
{
commonData = new CommonTestFixture(context);
commonData.HostUrl =
commonData.DataLakeAnalyticsManagementHelper.TryCreateDataLakeAnalyticsAccount(
commonData.ResourceGroupName,
commonData.Location,
commonData.DataLakeStoreAccountName,
commonData.SecondDataLakeAnalyticsAccountName
);
// Wait 5 minutes for the account setup
TestUtilities.Wait(300000);
commonData.DataLakeAnalyticsManagementHelper.CreateCatalog(
commonData.ResourceGroupName,
commonData.SecondDataLakeAnalyticsAccountName,
commonData.DatabaseName,
commonData.TableName,
commonData.TvfName,
commonData.ViewName,
commonData.ProcName
);
using (var clientToUse = commonData.GetDataLakeAnalyticsCatalogManagementClient(context))
{
// Create the credential
clientToUse.Catalog.CreateCredential(
commonData.SecondDataLakeAnalyticsAccountName,
commonData.DatabaseName,
commonData.SecretName,
new DataLakeAnalyticsCatalogCredentialCreateParameters
{
UserId = TestUtilities.GenerateGuid("fakeUserId01").ToString(),
Password = commonData.SecretPwd,
Uri = "https://adlasecrettest.contoso.com:443",
}
);
// Attempt to create the secret again, which should throw
Assert.Throws <CloudException>(
() =>
clientToUse.Catalog.CreateCredential(
commonData.SecondDataLakeAnalyticsAccountName,
commonData.DatabaseName,
commonData.SecretName,
new DataLakeAnalyticsCatalogCredentialCreateParameters
{
UserId = TestUtilities.GenerateGuid("fakeUserId02").ToString(),
Password = commonData.SecretPwd,
Uri = "https://adlasecrettest.contoso.com:443",
}
)
);
// Create another credential
var secondSecretName = commonData.SecretName + "dup";
clientToUse.Catalog.CreateCredential(
commonData.SecondDataLakeAnalyticsAccountName,
commonData.DatabaseName,
secondSecretName,
new DataLakeAnalyticsCatalogCredentialCreateParameters
{
UserId = TestUtilities.GenerateGuid("fakeUserId03").ToString(),
Password = commonData.SecretPwd,
Uri = "https://adlasecrettest.contoso.com:443",
}
);
// Get the credential and ensure the response contains a date.
var secretGetResponse =
clientToUse.Catalog.GetCredential(
commonData.SecondDataLakeAnalyticsAccountName,
commonData.DatabaseName, commonData.SecretName);
Assert.NotNull(secretGetResponse);
Assert.NotNull(secretGetResponse.Name);
// Get the Credential list
var credListResponse = clientToUse.Catalog.ListCredentials(
commonData.SecondDataLakeAnalyticsAccountName,
commonData.DatabaseName);
Assert.True(credListResponse.Count() >= 1);
// Look for the credential we created
Assert.Contains(credListResponse, cred => cred.Name.Equals(commonData.SecretName));
// Get the specific credential as well
var credGetResponse = clientToUse.Catalog.GetCredential(
commonData.SecondDataLakeAnalyticsAccountName,
commonData.DatabaseName, commonData.SecretName);
Assert.Equal(commonData.SecretName, credGetResponse.Name);
// Delete the credential
clientToUse.Catalog.DeleteCredential(
commonData.SecondDataLakeAnalyticsAccountName,
commonData.DatabaseName, commonData.SecretName,
new DataLakeAnalyticsCatalogCredentialDeleteParameters(commonData.SecretPwd));
// Try to get the credential which should throw
Assert.Throws <CloudException>(() => clientToUse.Catalog.GetCredential(
commonData.SecondDataLakeAnalyticsAccountName,
commonData.DatabaseName, commonData.SecretName));
// Re-create and delete the credential using cascade = true, which should still succeed.
clientToUse.Catalog.CreateCredential(
commonData.SecondDataLakeAnalyticsAccountName,
commonData.DatabaseName, commonData.SecretName,
new DataLakeAnalyticsCatalogCredentialCreateParameters
{
Password = commonData.SecretPwd,
Uri = "https://adlasecrettest.contoso.com:443",
UserId = TestUtilities.GenerateGuid("fakeUserId01").ToString()
});
clientToUse.Catalog.DeleteCredential(
commonData.SecondDataLakeAnalyticsAccountName,
commonData.DatabaseName, commonData.SecretName,
new DataLakeAnalyticsCatalogCredentialDeleteParameters(commonData.SecretPwd), cascade: true);
// Try to get the credential which should throw
Assert.Throws <CloudException>(() => clientToUse.Catalog.GetCredential(
commonData.SecondDataLakeAnalyticsAccountName,
commonData.DatabaseName, commonData.SecretName));
// TODO: once support is available for delete all credentials add tests here for that.
}
}
}
public void GetCatalogItemsTest()
{
// This test currently tests for Database, table TVF, view, types and procedure, and ACLs
using (var context = MockContext.Start(this.GetType().FullName))
{
commonData = new CommonTestFixture(context);
commonData.HostUrl =
commonData.DataLakeAnalyticsManagementHelper.TryCreateDataLakeAnalyticsAccount(
commonData.ResourceGroupName,
commonData.Location,
commonData.DataLakeStoreAccountName,
commonData.SecondDataLakeAnalyticsAccountName
);
// Wait 5 minutes for the account setup
TestUtilities.Wait(300000);
commonData.DataLakeAnalyticsManagementHelper.CreateCatalog(
commonData.ResourceGroupName,
commonData.SecondDataLakeAnalyticsAccountName,
commonData.DatabaseName,
commonData.TableName,
commonData.TvfName,
commonData.ViewName,
commonData.ProcName);
using (var clientToUse = commonData.GetDataLakeAnalyticsCatalogManagementClient(context))
{
var dbListResponse =
clientToUse.Catalog.ListDatabases(
commonData.SecondDataLakeAnalyticsAccountName
);
Assert.True(dbListResponse.Count() >= 1);
// Look for the db we created
Assert.Contains(dbListResponse, db => db.Name.Equals(commonData.DatabaseName));
// Get the specific Database as well
var dbGetResponse =
clientToUse.Catalog.GetDatabase(
commonData.SecondDataLakeAnalyticsAccountName,
commonData.DatabaseName
);
Assert.Equal(commonData.DatabaseName, dbGetResponse.Name);
// Get the table list
var tableListResponse =
clientToUse.Catalog.ListTables(
commonData.SecondDataLakeAnalyticsAccountName,
commonData.DatabaseName,
CommonTestFixture.SchemaName
);
Assert.True(tableListResponse.Count() >= 1);
Assert.True(tableListResponse.ElementAt(0).ColumnList != null && tableListResponse.ElementAt(0).ColumnList.Count() > 0);
// Look for the table we created
Assert.Contains(tableListResponse, table => table.Name.Equals(commonData.TableName));
// Get the table list with only basic info
tableListResponse =
clientToUse.Catalog.ListTables(
commonData.SecondDataLakeAnalyticsAccountName,
commonData.DatabaseName,
CommonTestFixture.SchemaName,
basic: true
);
Assert.True(tableListResponse.Count() >= 1);
Assert.True(tableListResponse.ElementAt(0).ColumnList == null || tableListResponse.ElementAt(0).ColumnList.Count() == 0);
// Get the table list in just the db
tableListResponse =
clientToUse.Catalog.ListTablesByDatabase(
commonData.SecondDataLakeAnalyticsAccountName,
commonData.DatabaseName
);
Assert.True(tableListResponse.Count() >= 1);
Assert.True(tableListResponse.ElementAt(0).ColumnList != null && tableListResponse.ElementAt(0).ColumnList.Count > 0);
// Look for the table we created
Assert.Contains(tableListResponse, table => table.Name.Equals(commonData.TableName));
// Get the table list in the db with only basic info
tableListResponse =
clientToUse.Catalog.ListTablesByDatabase(
commonData.SecondDataLakeAnalyticsAccountName,
commonData.DatabaseName,
basic: true
);
Assert.True(tableListResponse.Count() >= 1);
Assert.True(tableListResponse.ElementAt(0).ColumnList == null || tableListResponse.ElementAt(0).ColumnList.Count() == 0);
// Get preview of the specific table
var tablePreviewGetResponse =
clientToUse.Catalog.PreviewTable(
commonData.SecondDataLakeAnalyticsAccountName,
commonData.DatabaseName,
CommonTestFixture.SchemaName,
commonData.TableName
);
Assert.True(tablePreviewGetResponse.TotalRowCount > 0);
Assert.True(tablePreviewGetResponse.TotalColumnCount > 0);
Assert.True(tablePreviewGetResponse.Rows != null && tablePreviewGetResponse.Rows.Count() > 0);
Assert.True(tablePreviewGetResponse.Schema != null && tablePreviewGetResponse.Schema.Count() > 0);
Assert.NotNull(tablePreviewGetResponse.Schema[0].Name);
Assert.NotNull(tablePreviewGetResponse.Schema[0].Type);
// Get the specific table as well
var tableGetResponse =
clientToUse.Catalog.GetTable(
commonData.SecondDataLakeAnalyticsAccountName,
commonData.DatabaseName,
CommonTestFixture.SchemaName,
commonData.TableName
);
Assert.Equal(commonData.TableName, tableGetResponse.Name);
// Get the tvf list
var tvfListResponse =
clientToUse.Catalog.ListTableValuedFunctions(
commonData.SecondDataLakeAnalyticsAccountName,
commonData.DatabaseName,
CommonTestFixture.SchemaName
);
Assert.True(tvfListResponse.Count() >= 1);
// Look for the tvf we created
Assert.Contains(tvfListResponse, tvf => tvf.Name.Equals(commonData.TvfName));
// Get tvf list in the database
tvfListResponse =
clientToUse.Catalog.ListTableValuedFunctionsByDatabase(
commonData.SecondDataLakeAnalyticsAccountName,
commonData.DatabaseName
);
Assert.True(tvfListResponse.Count() >= 1);
// look for the tvf we created
Assert.Contains(tvfListResponse, tvf => tvf.Name.Equals(commonData.TvfName));
// Get the specific tvf as well
var tvfGetResponse =
clientToUse.Catalog.GetTableValuedFunction(
commonData.SecondDataLakeAnalyticsAccountName,
commonData.DatabaseName,
CommonTestFixture.SchemaName,
commonData.TvfName
);
Assert.Equal(commonData.TvfName, tvfGetResponse.Name);
// Get the view list
var viewListResponse =
clientToUse.Catalog.ListViews(
commonData.SecondDataLakeAnalyticsAccountName,
commonData.DatabaseName,
CommonTestFixture.SchemaName
);
Assert.True(viewListResponse.Count() >= 1);
// Look for the view we created
Assert.Contains(viewListResponse, view => view.Name.Equals(commonData.ViewName));
// Get the view list from just the database
viewListResponse =
clientToUse.Catalog.ListViewsByDatabase(
commonData.SecondDataLakeAnalyticsAccountName,
commonData.DatabaseName
);
Assert.True(viewListResponse.Count() >= 1);
// Look for the view we created
Assert.Contains(viewListResponse, view => view.Name.Equals(commonData.ViewName));
// Get the specific view as well
var viewGetResponse =
clientToUse.Catalog.GetView(
commonData.SecondDataLakeAnalyticsAccountName,
commonData.DatabaseName,
CommonTestFixture.SchemaName,
commonData.ViewName
);
Assert.Equal(commonData.ViewName, viewGetResponse.Name);
// Get the procedure list
var procListResponse =
clientToUse.Catalog.ListProcedures(
commonData.SecondDataLakeAnalyticsAccountName,
commonData.DatabaseName,
CommonTestFixture.SchemaName
);
Assert.True(procListResponse.Count() >= 1);
// Look for the procedure we created
Assert.Contains(procListResponse, proc => proc.Name.Equals(commonData.ProcName));
// Get the specific procedure as well
var procGetResponse =
clientToUse.Catalog.GetProcedure(
commonData.SecondDataLakeAnalyticsAccountName,
commonData.DatabaseName,
CommonTestFixture.SchemaName,
commonData.ProcName
);
Assert.Equal(commonData.ProcName, procGetResponse.Name);
// Get the partition list
var partitionList =
clientToUse.Catalog.ListTablePartitions(
commonData.SecondDataLakeAnalyticsAccountName,
commonData.DatabaseName,
CommonTestFixture.SchemaName,
commonData.TableName
);
Assert.True(partitionList.Count() >= 1);
var specificPartition = partitionList.First();
// Get preview of the specific partition
var partitionPreviewGetResponse =
clientToUse.Catalog.PreviewTablePartition(
commonData.SecondDataLakeAnalyticsAccountName,
commonData.DatabaseName,
CommonTestFixture.SchemaName,
commonData.TableName,
specificPartition.Name
);
Assert.True(partitionPreviewGetResponse.TotalRowCount > 0);
Assert.True(partitionPreviewGetResponse.TotalColumnCount > 0);
Assert.True(partitionPreviewGetResponse.Rows != null && partitionPreviewGetResponse.Rows.Count() > 0);
Assert.True(partitionPreviewGetResponse.Schema != null && partitionPreviewGetResponse.Schema.Count() > 0);
Assert.NotNull(tablePreviewGetResponse.Schema[0].Name);
Assert.NotNull(tablePreviewGetResponse.Schema[0].Type);
// Get the specific partition as well
var partitionGetResponse =
clientToUse.Catalog.GetTablePartition(
commonData.SecondDataLakeAnalyticsAccountName,
commonData.DatabaseName,
CommonTestFixture.SchemaName,
commonData.TableName,
specificPartition.Name
);
Assert.Equal(specificPartition.Name, partitionGetResponse.Name);
// Get the fragment list
var fragmentList =
clientToUse.Catalog.ListTableFragments(
commonData.SecondDataLakeAnalyticsAccountName,
commonData.DatabaseName,
CommonTestFixture.SchemaName,
commonData.TableName
);
Assert.NotNull(fragmentList);
Assert.NotEmpty(fragmentList);
// Get all the types
var typeGetResponse =
clientToUse.Catalog.ListTypes(
commonData.SecondDataLakeAnalyticsAccountName,
commonData.DatabaseName,
CommonTestFixture.SchemaName
);
Assert.NotNull(typeGetResponse);
Assert.NotEmpty(typeGetResponse);
// Get all the types that are not complex
typeGetResponse =
clientToUse.Catalog.ListTypes(
commonData.SecondDataLakeAnalyticsAccountName,
commonData.DatabaseName,
CommonTestFixture.SchemaName,
new Microsoft.Rest.Azure.OData.ODataQuery <USqlType> {
Filter = "isComplexType eq false"
}
);
Assert.NotNull(typeGetResponse);
Assert.NotEmpty(typeGetResponse);
Assert.DoesNotContain(typeGetResponse, type => type.IsComplexType.Value);
// Prepare to grant/revoke ACLs
var principalId = TestUtilities.GenerateGuid();
var grantAclParam = new AclCreateOrUpdateParameters
{
AceType = AclType.User,
PrincipalId = principalId,
Permission = PermissionType.Use
};
var revokeAclParam = new AclDeleteParameters
{
AceType = AclType.User,
PrincipalId = principalId
};
// Get the initial number of ACLs by db
var aclByDbListResponse =
clientToUse.Catalog.ListAclsByDatabase(
commonData.SecondDataLakeAnalyticsAccountName,
commonData.DatabaseName
);
var aclByDbCount = aclByDbListResponse.Count();
// Get the initial number of ACLs by catalog
var aclListResponse =
clientToUse.Catalog.ListAcls(
commonData.SecondDataLakeAnalyticsAccountName
);
var aclCount = aclListResponse.Count();
// Grant ACL to the db
clientToUse.Catalog.GrantAclToDatabase(
commonData.SecondDataLakeAnalyticsAccountName,
commonData.DatabaseName,
grantAclParam
);
aclByDbListResponse =
clientToUse.Catalog.ListAclsByDatabase(
commonData.SecondDataLakeAnalyticsAccountName,
commonData.DatabaseName
);
var acl = aclByDbListResponse.Last();
// Confirm the ACL's information
Assert.Equal(aclByDbCount + 1, aclByDbListResponse.Count());
Assert.Equal(AclType.User, acl.AceType);
Assert.Equal(principalId, acl.PrincipalId);
Assert.Equal(PermissionType.Use, acl.Permission);
// Revoke ACL from the db
clientToUse.Catalog.RevokeAclFromDatabase(
commonData.SecondDataLakeAnalyticsAccountName,
commonData.DatabaseName,
revokeAclParam
);
aclByDbListResponse =
clientToUse.Catalog.ListAclsByDatabase(
commonData.SecondDataLakeAnalyticsAccountName,
commonData.DatabaseName
);
Assert.Equal(aclByDbCount, aclByDbListResponse.Count());
// Grant ACL to the catalog
clientToUse.Catalog.GrantAcl(
commonData.SecondDataLakeAnalyticsAccountName,
grantAclParam
);
aclListResponse =
clientToUse.Catalog.ListAcls(
commonData.SecondDataLakeAnalyticsAccountName
);
acl = aclListResponse.Last();
// Confirm the ACL's information
Assert.Equal(aclCount + 1, aclListResponse.Count());
Assert.Equal(AclType.User, acl.AceType);
Assert.Equal(principalId, acl.PrincipalId);
Assert.Equal(PermissionType.Use, acl.Permission);
// Revoke ACL from the catalog
clientToUse.Catalog.RevokeAcl(
commonData.SecondDataLakeAnalyticsAccountName,
revokeAclParam
);
aclListResponse =
clientToUse.Catalog.ListAcls(
commonData.SecondDataLakeAnalyticsAccountName
);
Assert.Equal(aclCount, aclListResponse.Count());
}
}
}
public void SubmitGetListCancelTest()
{
using (var context = MockContext.Start(this.GetType().FullName))
{
commonData = new CommonTestFixture(context);
commonData.HostUrl =
commonData.DataLakeAnalyticsManagementHelper.TryCreateDataLakeAnalyticsAccount(commonData.ResourceGroupName,
commonData.Location, commonData.DataLakeStoreAccountName, commonData.SecondDataLakeAnalyticsAccountName);
// TODO: Remove this sleep once defect 5022906 is fixed
TestUtilities.Wait(120000); // Sleep for two minutes to give the account a chance to provision the queue
var clientToUse = this.GetDataLakeAnalyticsJobManagementClient(context);
Guid jobId = TestUtilities.GenerateGuid();
var secondId = TestUtilities.GenerateGuid();
// Submit a job to the account
var jobToSubmit = new JobInformation
{
Name = "azure sdk data lake analytics job",
DegreeOfParallelism = 2,
Type = JobType.USql,
Properties = new USqlJobProperties
{
// TODO: figure out why this is no longer showing up as a property
// Type = JobType.USql,
Script = "DROP DATABASE IF EXISTS testdb; CREATE DATABASE testdb;"
},
JobId = jobId
};
// check to make sure the job doesn't already exist
Assert.False(clientToUse.Job.Exists(commonData.SecondDataLakeAnalyticsAccountName, jobId));
var jobCreateResponse = clientToUse.Job.Create(commonData.SecondDataLakeAnalyticsAccountName, jobId, jobToSubmit);
Assert.NotNull(jobCreateResponse);
// Cancel the job
clientToUse.Job.Cancel(commonData.SecondDataLakeAnalyticsAccountName, jobCreateResponse.JobId.GetValueOrDefault());
// check to make sure the job does exist now
Assert.True(clientToUse.Job.Exists(commonData.SecondDataLakeAnalyticsAccountName, jobId));
// Get the job and ensure that it says it was cancelled.
var getCancelledJobResponse = clientToUse.Job.Get(commonData.SecondDataLakeAnalyticsAccountName, jobCreateResponse.JobId.GetValueOrDefault());
Assert.Equal(JobResult.Cancelled, getCancelledJobResponse.Result);
Assert.NotNull(getCancelledJobResponse.ErrorMessage);
Assert.NotEmpty(getCancelledJobResponse.ErrorMessage);
// Resubmit the job
jobToSubmit.JobId = secondId;
jobCreateResponse = clientToUse.Job.Create(commonData.SecondDataLakeAnalyticsAccountName, secondId, jobToSubmit);
Assert.NotNull(jobCreateResponse);
// Poll the job until it finishes
var getJobResponse = clientToUse.Job.Get(commonData.SecondDataLakeAnalyticsAccountName, jobCreateResponse.JobId.GetValueOrDefault());
Assert.NotNull(getJobResponse);
int maxWaitInSeconds = 180; // 3 minutes should be long enough
int curWaitInSeconds = 0;
while (getJobResponse.State != JobState.Ended && curWaitInSeconds < maxWaitInSeconds)
{
// wait 5 seconds before polling again
TestUtilities.Wait(5000);
curWaitInSeconds += 5;
getJobResponse = clientToUse.Job.Get(commonData.SecondDataLakeAnalyticsAccountName, jobCreateResponse.JobId.GetValueOrDefault());
Assert.NotNull(getJobResponse);
}
Assert.True(curWaitInSeconds <= maxWaitInSeconds);
// Verify the job completes successfully
Assert.True(
getJobResponse.State == JobState.Ended && getJobResponse.Result == JobResult.Succeeded,
string.Format("Job: {0} did not return success. Current job state: {1}. Actual result: {2}. Error (if any): {3}",
getJobResponse.JobId, getJobResponse.State, getJobResponse.Result, getJobResponse.ErrorMessage));
var listJobResponse = clientToUse.Job.List(commonData.SecondDataLakeAnalyticsAccountName, null);
Assert.NotNull(listJobResponse);
Assert.True(listJobResponse.Any(job => job.JobId == getJobResponse.JobId));
// Just compile the job, which requires a jobId in the job object.
jobToSubmit.JobId = getJobResponse.JobId;
var compileResponse = clientToUse.Job.Build(commonData.SecondDataLakeAnalyticsAccountName, jobToSubmit);
Assert.NotNull(compileResponse);
// now compile a broken job and verify diagnostics report an error
jobToSubmit.Properties.Script = "DROP DATABASE IF EXIST FOO; CREATE DATABASE FOO;";
compileResponse = clientToUse.Job.Build(commonData.SecondDataLakeAnalyticsAccountName, jobToSubmit);
Assert.NotNull(compileResponse);
Assert.Equal(1, ((USqlJobProperties)compileResponse.Properties).Diagnostics.Count);
Assert.Equal(SeverityTypes.Error, ((USqlJobProperties)compileResponse.Properties).Diagnostics[0].Severity);
Assert.Equal(18, ((USqlJobProperties)compileResponse.Properties).Diagnostics[0].ColumnNumber);
Assert.Equal(22, ((USqlJobProperties)compileResponse.Properties).Diagnostics[0].End);
Assert.Equal(17, ((USqlJobProperties)compileResponse.Properties).Diagnostics[0].Start);
Assert.Equal(1, ((USqlJobProperties)compileResponse.Properties).Diagnostics[0].LineNumber);
Assert.Contains("E_CSC_USER_SYNTAXERROR", ((USqlJobProperties)compileResponse.Properties).Diagnostics[0].Message);
// list the jobs both with a hand crafted query string and using the parameters
listJobResponse = clientToUse.Job.List(commonData.SecondDataLakeAnalyticsAccountName, select: "jobId");
Assert.NotNull(listJobResponse);
Assert.True(listJobResponse.Any(job => job.JobId == getJobResponse.JobId));
}
}
