[TestCategory("SkipWhenLiveUnitTesting")] // Ignore for Live Unit Testing
public void EndToEndAddPowerBIWorkspaceUserIndividualScope()
{
// TODO: Note that unlike the admin APIs, this API will throw an error when attempting to add a user that already has access to the workspace
// This means that this end-to-end test can fail depending on when it is run with the other tests
// This can't be elegantly solved until users are available on the non-admin GET endpoint
using (var ps = System.Management.Automation.PowerShell.Create())
{
// Arrange
ProfileTestUtilities.ConnectToPowerBI(ps);
var workspace = WorkspacesTestUtilities.GetFirstWorkspace(ps, PowerBIUserScope.Individual);
WorkspacesTestUtilities.AssertShouldContinueIndividualTest(workspace);
var emailAddress = "*****@*****.**";
var parameters = new Dictionary <string, object>()
{
{ nameof(AddPowerBIWorkspaceUser.Scope), PowerBIUserScope.Individual },
{ nameof(AddPowerBIWorkspaceUser.Id), workspace.Id },
{ nameof(AddPowerBIWorkspaceUser.UserPrincipalName), emailAddress },
{ nameof(AddPowerBIWorkspaceUser.AccessRight), WorkspaceUserAccessRight.Admin }
};
ps.AddCommand(Cmdlet).AddParameters(parameters);
// Act
var results = ps.Invoke();
// Assert
TestUtilities.AssertNoCmdletErrors(ps);
Assert.IsNotNull(results);
Assert.IsTrue(results.Any());
}
}
[TestCategory("SkipWhenLiveUnitTesting")] // Ignore for Live Unit Testing
public void EndToEndSetWorkspaceOrganizationScopeCapacityParameterSet()
{
using (var ps = System.Management.Automation.PowerShell.Create())
{
// Arrange
ProfileTestUtilities.ConnectToPowerBI(ps);
var workspace = WorkspacesTestUtilities.GetFirstWorkspaceInOrganization(ps);
WorkspacesTestUtilities.AssertShouldContinueOrganizationTest(workspace);
var capacityId = WorkspacesTestUtilities.GetFirstCapacityInOrganization(ps);
var parameters = new Dictionary <string, object>
{
{ nameof(SetPowerBIWorkspace.Scope), PowerBIUserScope.Organization },
{ nameof(SetPowerBIWorkspace.Id), workspace.Id },
{ nameof(SetPowerBIWorkspace.CapacityId), capacityId }
};
ps.AddCommand(Cmdlet).AddParameters(parameters);
// Act
var results = ps.Invoke();
// Assert
TestUtilities.AssertNoCmdletErrors(ps);
Assert.IsNotNull(results);
}
}
[TestCategory("SkipWhenLiveUnitTesting")] // Ignore for Live Unit Testing
public void EndToEndGetPowerBIDatasourceIndividualScope()
{
/*
* Requirement to run test:
* Need at least one dataset containing a datasource assigned to the user logging into the test.
*/
using (var ps = System.Management.Automation.PowerShell.Create())
{
// Arrange
ProfileTestUtilities.ConnectToPowerBI(ps);
ps.AddCommand(GetPowerBIDatasetTests.GetPowerBIDatasetCmdletInfo);
var existingDatasets = ps.Invoke();
TestUtilities.AssertNoCmdletErrors(ps);
ps.Commands.Clear();
if (!existingDatasets.Any())
{
Assert.Inconclusive("No datasets returned. Verify you have datasets under your logged in user.");
}
var testDataset = existingDatasets.Select(d => (Dataset)d.BaseObject).FirstOrDefault();
ps.AddCommand(GetPowerBIDatasourceCmdletInfo).AddParameter(nameof(GetPowerBIDatasource.DatasetId), testDataset.Id.ToString());
// Act
var result = ps.Invoke();
// Assert
TestUtilities.AssertNoCmdletErrors(ps);
Assert.IsNotNull(result);
Assert.IsTrue(result.Count > 0);
}
}
[TestCategory("SkipWhenLiveUnitTesting")] // Ignore for Live Unit Testing
public void EndToEndRestoreWorkspaceOrganizationScopeWorkspaceParameterSet()
{
/*
* Test requires a deleted preview workspace (v2) to exist and login as an administrator
*/
using (var ps = System.Management.Automation.PowerShell.Create())
{
// Arrange
ProfileTestUtilities.ConnectToPowerBI(ps);
var workspace = WorkspacesTestUtilities.GetFirstDeletedWorkspaceInOrganization(ps);
WorkspacesTestUtilities.AssertShouldContinueOrganizationTest(workspace);
var updatedName = TestUtilities.GetRandomString();
var emailAddress = "*****@*****.**"; //change to valid test user email
var parameters = new Dictionary <string, object>
{
{ nameof(RestorePowerBIWorkspace.Scope), PowerBIUserScope.Organization },
{ nameof(RestorePowerBIWorkspace.RestoredName), updatedName },
{ nameof(RestorePowerBIWorkspace.AdminUserPrincipalName), emailAddress },
{ nameof(RestorePowerBIWorkspace.Workspace), workspace },
};
ps.AddCommand(Cmdlet).AddParameters(parameters);
// Act
var results = ps.Invoke();
// Assert
TestUtilities.AssertNoCmdletErrors(ps);
Assert.IsNotNull(results);
var updatedWorkspace = WorkspacesTestUtilities.GetWorkspace(ps, PowerBIUserScope.Organization, workspace.Id);
Assert.AreEqual(updatedName, updatedWorkspace.Name);
Assert.IsTrue(updatedWorkspace.Users
.Any(x => x.UserPrincipalName.Equals(emailAddress, StringComparison.OrdinalIgnoreCase) &&
x.AccessRight == WorkspaceUserAccessRight.Admin.ToString()));
}
}
[TestCategory("SkipWhenLiveUnitTesting")] // Ignore for Live Unit Testing
public void EndToEndSetWorkspaceIndividualScope()
{
using (var ps = System.Management.Automation.PowerShell.Create())
{
// Arrange
ProfileTestUtilities.ConnectToPowerBI(ps);
var parameters = new Dictionary <string, object>
{
{ nameof(SetPowerBIWorkspace.Scope), PowerBIUserScope.Individual },
{ nameof(SetPowerBIWorkspace.Workspace), new Workspace() }
};
ps.AddCommand(Cmdlet).AddParameters(parameters);
try
{
// Act
ps.Invoke();
Assert.Fail("Should not have reached this point");
}
catch (CmdletInvocationException ex)
{
// Assert
Assert.AreEqual(ex.InnerException.GetType(), typeof(NotImplementedException));
}
}
}
[TestCategory("SkipWhenLiveUnitTesting")] // Ignore for Live Unit Testing
public void EndToEndSetWorkspaceOrganizationScopeWorkspaceParameterSet()
{
using (var ps = System.Management.Automation.PowerShell.Create())
{
// Arrange
ProfileTestUtilities.ConnectToPowerBI(ps);
var workspace = WorkspacesTestUtilities.GetFirstWorkspaceInOrganization(ps);
WorkspacesTestUtilities.AssertShouldContinueOrganizationTest(workspace);
var updatedName = TestUtilities.GetRandomString();
var updatedDescription = TestUtilities.GetRandomString();
workspace.Name = updatedName;
workspace.Description = updatedDescription;
var parameters = new Dictionary <string, object>
{
{ nameof(SetPowerBIWorkspace.Scope), PowerBIUserScope.Organization },
{ nameof(SetPowerBIWorkspace.Workspace), workspace }
};
ps.AddCommand(Cmdlet).AddParameters(parameters);
// Act
var results = ps.Invoke();
// Assert
TestUtilities.AssertNoCmdletErrors(ps);
Assert.IsNotNull(results);
var updatedWorkspace = WorkspacesTestUtilities.GetWorkspace(ps, PowerBIUserScope.Organization, workspace.Id);
Assert.AreEqual(updatedName, updatedWorkspace.Name);
Assert.AreEqual(updatedDescription, updatedWorkspace.Description);
}
}
[TestCategory("SkipWhenLiveUnitTesting")] // Ignore for Live Unit Testing
public void EndToEndRemovePowerBIRows()
{
using (var ps = System.Management.Automation.PowerShell.Create())
{
// Arrange
ProfileTestUtilities.ConnectToPowerBI(ps, PowerBIEnvironmentType.Public);
ps.AddCommand(GetPowerBIDatasetCmdletInfo).AddParameter(nameof(GetPowerBITable.Scope), PowerBIUserScope.Individual);
var dataSetResults = ps.Invoke();
ps.Commands.Clear();
var datasetId = dataSetResults.Where(x => (bool)x.Members["addRowsAPIEnabled"].Value == true).First().Members["Id"].Value;
ps.AddCommand(GetPowerBITableCmdletInfo)
.AddParameter(nameof(GetPowerBITable.DatasetId), datasetId);
var tableResults = ps.Invoke();
ps.Commands.Clear();
var table = tableResults.First().BaseObject as Table;
ps.AddCommand(RemovePowerBIRowCmdletInfo)
.AddParameter(nameof(RemovePowerBIRow.DatasetId), datasetId)
.AddParameter(nameof(RemovePowerBIRow.TableName), table.Name);
// Act
var result = ps.Invoke();
// Assert
TestUtilities.AssertNoCmdletErrors(ps);
Assert.IsNotNull(result);
Assert.IsTrue(result.Count > 0);
}
}
[TestCategory("SkipWhenLiveUnitTesting")] // Ignore for Live Unit Testing
public void EndToEndAddPowerBIWorkspaceUserOrganizationScope()
{
using (var ps = System.Management.Automation.PowerShell.Create())
{
// Arrange
ProfileTestUtilities.ConnectToPowerBI(ps);
var workspace = WorkspacesTestUtilities.GetFirstWorkspaceInOrganization(ps);
WorkspacesTestUtilities.AssertShouldContinueOrganizationTest(workspace);
var emailAddress = "*****@*****.**";
var parameters = new Dictionary <string, object>()
{
{ nameof(AddPowerBIWorkspaceUser.Scope), PowerBIUserScope.Organization },
{ nameof(AddPowerBIWorkspaceUser.Id), workspace.Id },
{ nameof(AddPowerBIWorkspaceUser.UserPrincipalName), emailAddress },
{ nameof(AddPowerBIWorkspaceUser.AccessRight), WorkspaceUserAccessRight.Member }
};
ps.AddCommand(Cmdlet).AddParameters(parameters);
// Act
var results = ps.Invoke();
// Assert
TestUtilities.AssertNoCmdletErrors(ps);
Assert.IsNotNull(results);
var updatedWorkspace = WorkspacesTestUtilities.GetWorkspace(ps, PowerBIUserScope.Organization, workspace.Id);
Assert.IsTrue(updatedWorkspace.Users
.Any(x => x.UserPrincipalName.Equals(emailAddress, StringComparison.OrdinalIgnoreCase) &&
x.AccessRight == WorkspaceUserAccessRight.Member.ToString()));
}
}
[TestCategory("SkipWhenLiveUnitTesting")] // Ignore for Live Unit Testing
public void EndToEndGetWorkspacesOrganizationScopeAndDeleted()
{
/*
* Test requires at least one deleted workspace and login as an administrator
*/
using (var ps = System.Management.Automation.PowerShell.Create())
{
// Arrange
ProfileTestUtilities.ConnectToPowerBI(ps);
var deletedWorkspace = WorkspacesTestUtilities.GetFirstDeletedWorkspaceInOrganization(ps);
WorkspacesTestUtilities.AssertShouldContinueOrganizationTest(deletedWorkspace);
var parameters = new Dictionary <string, object>()
{
{ nameof(GetPowerBIWorkspace.Scope), PowerBIUserScope.Organization },
{ nameof(GetPowerBIWorkspace.Deleted), true }
};
ps.AddCommand(WorkspacesTestUtilities.GetPowerBIWorkspaceCmdletInfo).AddParameters(parameters);
// Act
var results = ps.Invoke();
// Assert
TestUtilities.AssertNoCmdletErrors(ps);
Assert.IsNotNull(results);
if (!results.Any())
{
Assert.Inconclusive("No workspaces returned. Verify you have workspaces in your organization.");
}
var deletedWorkspaces = results.Select(x => (Workspace)x.BaseObject);
Assert.IsTrue(deletedWorkspaces.Any(x => x.Id == deletedWorkspace.Id));
}
}
[TestCategory("SkipWhenLiveUnitTesting")] // Ignore for Live Unit Testing
public void EndToEndGetPowerBITable_DatasetIdParameterSetName()
{
using (var ps = System.Management.Automation.PowerShell.Create())
{
// Arrange
ProfileTestUtilities.ConnectToPowerBI(ps, PowerBIEnvironmentType.Public);
ps.AddCommand(GetPowerBIDatasetCmdletInfo).AddParameter(nameof(GetPowerBITable.Scope), PowerBIUserScope.Individual);
var datasetResults = ps.Invoke();
ps.Commands.Clear();
var datasetId = datasetResults.FirstOrDefault(x => (bool)x.Members["AddRowsAPIEnabled"].Value == true).Members["Id"].Value;
ps.AddCommand(GetPowerBITableCmdletInfo)
.AddParameter(nameof(GetPowerBITable.DatasetId), datasetId)
.AddParameter(nameof(GetPowerBITable.Name), "Product");
// Act
var results = ps.Invoke();
// Assert
TestUtilities.AssertNoCmdletErrors(ps);
Assert.IsNotNull(results);
if (!results.Any())
{
Assert.Inconclusive("No tables returned. Verify you have tables under your logged in user.");
}
}
}
[TestCategory("SkipWhenLiveUnitTesting")] // Ignore for Live Unit Testing
public void EndToEndGetWorkspacesAllAndIndividualScope()
{
/*
* Test requires at least one workspace (group or preview workspace) and login as a user.
*/
using (var ps = System.Management.Automation.PowerShell.Create())
{
// Arrange
ProfileTestUtilities.ConnectToPowerBI(ps);
var parameters = new Dictionary <string, object>()
{
{ nameof(GetPowerBIWorkspace.Scope), PowerBIUserScope.Individual },
{ nameof(GetPowerBIWorkspace.All), true }
};
ps.AddCommand(WorkspacesTestUtilities.GetPowerBIWorkspaceCmdletInfo)
.AddParameters(parameters);
// Act
var results = ps.Invoke();
// Assert
TestUtilities.AssertNoCmdletErrors(ps);
Assert.IsNotNull(results);
if (!results.Any())
{
Assert.Inconclusive("No workspaces returned. Verify the user has workspaces.");
}
}
}
[TestCategory("SkipWhenLiveUnitTesting")] // Ignore for Live Unit Testing
public void EndToEndPipingDatasetIntoGetPowerBIDatasourceIndividualScope()
{
/*
* Requirement to run test:
* Need at least one dataset containing a datasource assigned to the user logging into the test.
*/
using (var ps = System.Management.Automation.PowerShell.Create())
{
// Arrange
ProfileTestUtilities.ConnectToPowerBI(ps, PowerBIEnvironmentType.Public);
ps.AddCommand(GetPowerBIDatasetTests.GetPowerBIDatasetCmdletInfo).AddCommand(GetPowerBIDatasourceCmdletInfo);
// Act
var results = ps.Invoke();
// Assert
TestUtilities.AssertNoCmdletErrors(ps);
Assert.IsNotNull(results);
if (!results.Any())
{
Assert.Inconclusive("No datasources returned. Verify you have datasources under your logged in user.");
}
Assert.IsTrue(results.Count > 0);
}
}
[TestCategory("SkipWhenLiveUnitTesting")] // Ignore for Live Unit Testing
public void EndToEndGetWorkspacesIndividualScopeAndFirst()
{
/*
* Test requires at least one workspace (group or preview workspace)
*/
using (var ps = System.Management.Automation.PowerShell.Create())
{
// Arrange
ProfileTestUtilities.ConnectToPowerBI(ps);
var parameters = new Dictionary <string, object>()
{
{ nameof(GetPowerBIWorkspace.Scope), PowerBIUserScope.Individual },
{ nameof(GetPowerBIWorkspace.First), 1 }
};
ps.AddCommand(WorkspacesTestUtilities.GetPowerBIWorkspaceCmdletInfo).AddParameters(parameters);
// Act
var results = ps.Invoke();
// Assert
TestUtilities.AssertNoCmdletErrors(ps);
Assert.IsNotNull(results);
if (!results.Any())
{
Assert.Inconclusive("No workspaces returned. Verify you are assigned or own any workspaces.");
}
Assert.AreEqual(1, results.Count);
}
}
[TestCategory("SkipWhenLiveUnitTesting")] // Ignore for Live Unit Testing
public void EndToEndExportPowerBIDataflowOrganizationScope_ByDataflow()
{
/*
* Requirement to run test:
* Need at least one dataflow assigned to the user logging into the test.
*/
try
{
using (var ps = System.Management.Automation.PowerShell.Create())
{
// Arrange
ProfileTestUtilities.ConnectToPowerBI(ps);
ps.AddCommand(GetPowerBIDataflowTests.GetPowerBIDataflowCmdletInfo).AddParameter(nameof(ExportPowerBIDataflow.Scope), PowerBIUserScope.Organization);
var existingDataflows = ps.Invoke();
TestUtilities.AssertNoCmdletErrors(ps);
ps.Commands.Clear();
if (!existingDataflows.Any())
{
Assert.Inconclusive("No dataflows returned. Verify you have dataflows under your logged in user.");
}
var testDataflow = existingDataflows.Select(d => (Dataflow)d.BaseObject).FirstOrDefault();
var parameters = new Dictionary <string, object>()
{
{ nameof(ExportPowerBIDataflow.Dataflow), testDataflow },
{ nameof(ExportPowerBIDataflow.Scope), PowerBIUserScope.Organization },
{ nameof(ExportPowerBIDataflow.OutFile), c_ExportedDataflowModel }
};
ps.AddCommand(ExportPowerBIDataflowCmdletInfo).AddParameters(parameters);
// Act
var result = ps.Invoke();
// Assert
TestUtilities.AssertNoCmdletErrors(ps);
Assert.IsNotNull(result);
Assert.IsTrue(File.Exists(c_ExportedDataflowModel));
}
}
finally
{
// always delete the test's exported file
File.Delete(c_ExportedDataflowModel);
}
}
public void EndToEndGetReportsWithoutLogin()
{
using (var ps = PowerShell.Create())
{
// Arrange
ProfileTestUtilities.SafeDisconnectFromPowerBI(ps);
ps.AddCommand(Cmdlet);
// Act
var results = ps.Invoke();
// Assert
Assert.Fail("Should not have reached this point");
}
}
[TestCategory("SkipWhenLiveUnitTesting")] // Ignore for Live Unit Testing
public void EndToEndRemovePowerBIReport()
{
using (var ps = System.Management.Automation.PowerShell.Create())
{
ProfileTestUtilities.ConnectToPowerBI(ps, PowerBIEnvironmentType.Public); // If login is needed
ps.AddCommand(new CmdletInfo($"{RemovePowerBIReport.CmdletVerb}-{RemovePowerBIReport.CmdletName}", typeof(RemovePowerBIReport)));
ps.AddParameter("Id", "fce8abb5-192b-4be2-b75e-b43bb93d8943");
ps.AddParameter("WorkspaceId", "kjsdfjs;sf");
var result = ps.Invoke();
// Add asserts to verify
TestUtilities.AssertNoCmdletErrors(ps);
}
}
[TestCategory("SkipWhenLiveUnitTesting")] // Ignore for Live Unit Testing
public void EndToEndGetPowerBIEncryptionKey()
{
using (var ps = System.Management.Automation.PowerShell.Create())
{
// Arrange
ProfileTestUtilities.ConnectToPowerBI(ps);
ps.AddCommand(GetPowerBIEncryptionKeyCmdletInfo);
// Act
var result = ps.Invoke();
// Assert
TestUtilities.AssertNoCmdletErrors(ps);
}
}
public void EndToEndGetWorkspacesWithoutLogin()
{
using (var ps = System.Management.Automation.PowerShell.Create())
{
// Arrange
ProfileTestUtilities.SafeDisconnectFromPowerBI(ps);
ps.AddCommand(WorkspacesTestUtilities.GetPowerBIWorkspaceCmdletInfo);
// Act
var result = ps.Invoke();
// Assert
Assert.Fail("Should not have reached this point");
}
}
[TestCategory("SkipWhenLiveUnitTesting")] // Ignore for Live Unit Testing
public void EndToEndNewDashboardInMyWorkspaceIndividualScope()
{
using (var ps = PowerShell.Create())
{
// Arrange
ProfileTestUtilities.ConnectToPowerBI(ps, PowerBIEnvironmentType.Public);
ps.AddCommand(Cmdlet)
.AddParameter(nameof(NewPowerBIReport.Name), "Test Dash: " + Guid.NewGuid().ToString());
// Act
var reportId = ps.Invoke();
// Assert
TestUtilities.AssertNoCmdletErrors(ps);
}
}
[TestCategory("SkipWhenLiveUnitTesting")] // Ignore for Live Unit Testing
public void EndToEndGetPowerBIWorkspaceEncryptionStatus()
{
using (var ps = System.Management.Automation.PowerShell.Create())
{
// Arrange
ProfileTestUtilities.ConnectToPowerBI(ps);
ps.AddCommand(GetPowerBIWorkspaceEncryptionStatusCmdletInfo)
.AddParameter(nameof(GetPowerBIWorkspaceEncryptionStatus.Name), MockName);
// Act
var result = ps.Invoke();
// Assert
TestUtilities.AssertNoCmdletErrors(ps);
}
}
[TestCategory("SkipWhenLiveUnitTesting")] // Ignore for Live Unit Testing
public void EndToEndGetOnPremisesDataGatewayClusterWithGatewayClusterId()
{
using (var ps = System.Management.Automation.PowerShell.Create())
{
// Arrange
ProfileTestUtilities.ConnectToPowerBI(ps);
ps.AddCommand(GetOnPremisesDataGatewayClusterInfo).AddParameter(nameof(GetOnPremisesDataGatewayCluster.GatewayClusterId), Guid.NewGuid());
// Act
var result = ps.Invoke();
// Assert
TestUtilities.AssertNoCmdletErrors(ps);
Assert.IsNotNull(result);
}
}
public void EndToEndNewDashboardWithoutLogin()
{
using (var ps = PowerShell.Create())
{
// Arrange
ProfileTestUtilities.SafeDisconnectFromPowerBI(ps);
ps.AddCommand(Cmdlet)
.AddParameter(nameof(NewPowerBIReport.Name), "Test Dash: " + Guid.NewGuid().ToString());
// Act
var results = ps.Invoke();
// Assert
Assert.Fail("Should not have reached this point");
}
}
[TestCategory("SkipWhenLiveUnitTesting")] // Ignore for Live Unit Testing
public void EndToEndGetOnPremisesDataGatewayInstaller()
{
using (var ps = System.Management.Automation.PowerShell.Create())
{
// Arrange
ProfileTestUtilities.ConnectToPowerBI(ps);
ps.AddCommand(GetOnPremisesDataGatewayInstallerInfo);
// Act
var result = ps.Invoke();
// Assert
TestUtilities.AssertNoCmdletErrors(ps);
Assert.IsNotNull(result);
}
}
public void EndToEndNewReportsWithoutLogin()
{
using (var ps = PowerShell.Create())
{
// Arrange
ProfileTestUtilities.SafeDisconnectFromPowerBI(ps);
ps.AddCommand(Cmdlet)
.AddParameter(nameof(NewPowerBIReport.Path), "./testreport.pbix");
// Act
var results = ps.Invoke();
// Assert
Assert.Fail("Should not have reached this point");
}
}
[TestCategory("SkipWhenLiveUnitTesting")] // Ignore for Live Unit Testing
public void EndToEndCopyReportIndividualScope()
{
using (var ps = PowerShell.Create())
{
// Arrange
ProfileTestUtilities.ConnectToPowerBI(ps, PowerBIEnvironmentType.Public);
ps.AddCommand(Cmdlet)
.AddParameter(nameof(CopyPowerBIReport.Name), "Copied Report: " + Guid.NewGuid().ToString())
.AddParameter(nameof(CopyPowerBIReport.Id), new Guid("30ca8f24-f628-45f7-a5ac-540c95e9b5e6"));
// Act
var reportId = ps.Invoke();
// Assert
TestUtilities.AssertNoCmdletErrors(ps);
}
}
[TestCategory("SkipWhenLiveUnitTesting")] // Ignore for Live Unit Testing
public void EndToEndNewReportIndividualScope()
{
using (var ps = PowerShell.Create())
{
// Arrange
ProfileTestUtilities.ConnectToPowerBI(ps, PowerBIEnvironmentType.Public);
ps.AddCommand(Cmdlet)
.AddParameter(nameof(NewPowerBIReport.Path), "./testreport.pbix")
.AddParameter(nameof(NewPowerBIReport.Name), "Test");
// Act
var reportId = ps.Invoke();
// Assert
TestUtilities.AssertNoCmdletErrors(ps);
}
}
[TestCategory("SkipWhenLiveUnitTesting")] // Ignore for Live Unit Testing
public void EndToEndGetPowerBIDatasetOrganizationScope()
{
using (var ps = System.Management.Automation.PowerShell.Create())
{
// Arrange
ProfileTestUtilities.ConnectToPowerBI(ps);
ps.AddCommand(GetPowerBIDatasetCmdletInfo).AddParameter("Scope", "Organization");
// Act
var result = ps.Invoke();
// Assert
TestUtilities.AssertNoCmdletErrors(ps);
Assert.IsNotNull(result);
Assert.IsTrue(result.Count > 0);
}
}
[TestCategory("SkipWhenLiveUnitTesting")] // Ignore for Live Unit Testing
public void EndToEndRotatePowerBIEncryptionKey()
{
using (var ps = System.Management.Automation.PowerShell.Create())
{
// Arrange
ProfileTestUtilities.ConnectToPowerBI(ps);
ps.AddCommand(SwitchPowerBIEncryptionKeyCmdletInfo)
.AddParameter(nameof(SwitchPowerBIEncryptionKey.Name), MockName)
.AddParameter(nameof(SwitchPowerBIEncryptionKey.KeyVaultKeyUri), MockKeyVaultKeyUri);
// Act
var result = ps.Invoke();
// Assert
TestUtilities.AssertNoCmdletErrors(ps);
}
}
public void EndToEndNewPowerBIWorkspaceTestWithoutLogin()
{
using (var ps = System.Management.Automation.PowerShell.Create())
{
// Arrange
ProfileTestUtilities.SafeDisconnectFromPowerBI(ps);
var parameters = new Dictionary <string, object>()
{
{ nameof(NewPowerBIWorkspace.Name), "Just a name" },
};
ps.AddCommand(Cmdlet).AddParameters(parameters);
// Act
var results = ps.Invoke();
// Assert
Assert.Fail("Should not have reached this point");
}
}
public void EndToEndGetPowerBIDatasourceWithoutLogin()
{
using (var ps = System.Management.Automation.PowerShell.Create())
{
// Arrange
ProfileTestUtilities.SafeDisconnectFromPowerBI(ps);
var parameters = new Dictionary <string, object>()
{
{ nameof(GetPowerBIDatasource.DatasetId), Guid.NewGuid() }
};
ps.AddCommand(GetPowerBIDatasourceCmdletInfo).AddParameters(parameters);
// Act
var results = ps.Invoke();
// Assert
Assert.Fail("Should not have reached this point");
}
}
