public void EnvironmentNegativeBadType()
 {
     using (var runspace = PowershellFactory.CreateAuthenticatedSession(TestContext))
     {
         using (var cmdlet = PowershellFactory.CreateCmdlet(runspace))
         {
             var name        = TestRandom.RandomString();
             var description = TestRandom.RandomString();
             cmdlet.AddCommand(UiPathStrings.AddUiPathEnvironment)
             .AddParameter(UiPathStrings.Name, name)
             .AddParameter(UiPathStrings.Description, description)
             .AddParameter(UiPathStrings.Type, "Invalid");
             // Not clear if it should be ParameterBindingValidationException or ValidationMetadataException
             // And ParameterBindingValidationException does not resolve...
             try
             {
                 Invoke <Environment>(cmdlet);
                 Assert.Fail("The Invoke was supposed to throw!");
             }
             catch (RuntimeException re)
             {
                 Assert.AreEqual("Cannot validate argument on parameter 'Type'. The argument \"Invalid\" does not belong to the set \"Dev,Test,Prod\" specified by the ValidateEnum attribute. Supply an argument that is in the set and then try the command again", re.Message);
             }
         }
     }
 }
        public void AssetAddRemovePositional()
        {
            using (var runspace = PowershellFactory.CreateAuthenticatedSession(TestContext))
            {
                Asset asset = null;

                // Positional add
                using (var cmdlet = PowershellFactory.CreateCmdlet(runspace))
                {
                    var assetName  = TestRandom.RandomString();
                    var assetValue = TestRandom.RandomString();
                    cmdlet.AddCommand(UiPathStrings.AddUiPathAsset)
                    .AddArgument(assetName)
                    .AddParameter(UiPathStrings.TextValue, assetValue);
                    var assets = Invoke <Asset>(cmdlet);

                    Validators.ValidateAssetResponse(assets, null, assetName, AssetDtoValueType.Text, assetValue);

                    asset = assets[0];
                }

                // positional remove by object
                using (var cmdlet = PowershellFactory.CreateCmdlet(runspace))
                {
                    cmdlet.AddCommand(UiPathStrings.RemoveUiPathAsset)
                    .AddArgument(asset);
                    Invoke(cmdlet);
                }
            }
        }
        public void EnvironmentAddType()
        {
            using (var runspace = PowershellFactory.CreateAuthenticatedSession(TestContext))
            {
                foreach (var envType in Enum.GetValues(typeof(EnvironmentDtoType)))
                {
                    using (var cmdlet = PowershellFactory.CreateCmdlet(runspace))
                    {
                        var name        = TestRandom.RandomString();
                        var description = TestRandom.RandomString();
                        cmdlet.AddCommand(UiPathStrings.AddUiPathEnvironment)
                        .AddParameter(UiPathStrings.Name, name)
                        .AddParameter(UiPathStrings.Description, description)
                        .AddParameter(UiPathStrings.Type, envType);
                        var environments = Invoke <Environment>(cmdlet);

                        Validators.ValidateEnvironmentResponse(environments, null, name, description, (EnvironmentDtoType)envType);

                        Api.DeleteEnvironmentById(environments[0].Id);

                        TestContext.WriteLine($"Validated Add-UiPathEnvironment type: {envType}");
                    }
                }
            }
        }
        public void FolderAddGetRemove()
        {
            using (var runspace = PowershellFactory.CreateAuthenticatedSession(TestContext))
            {
                var    displayName   = TestRandom.RandomAlphaNumeric();
                var    description   = TestRandom.RandomAlphaNumeric();
                long?  folderId      = null;
                Folder currentFolder = null;
                using (var cmdlet = PowershellFactory.CreateCmdlet(runspace))
                {
                    cmdlet.AddCommand(UiPathStrings.AddFolder)
                    .AddParameter(UiPathStrings.DisplayName, displayName)
                    .AddParameter(UiPathStrings.Description, description)
                    .AddParameter(UiPathStrings.PermissionModel, FolderDtoPermissionModel.FineGrained)
                    .AddParameter(UiPathStrings.ProvisionType, FolderDtoProvisionType.Automatic);
                    var folders = Invoke <Folder>(cmdlet);

                    Validators.ValidateFolderResponse(folders, null, displayName, description, FolderDtoProvisionType.Automatic, FolderDtoPermissionModel.FineGrained);

                    folderId = folders[0].Id;
                }

                using (var cmdlet = PowershellFactory.CreateCmdlet(runspace))
                {
                    cmdlet.AddCommand(UiPathStrings.GetFolder)
                    .AddParameter(UiPathStrings.Id, folderId);
                    var folders = Invoke <Folder>(cmdlet);
                    currentFolder = folders[0];

                    Validators.ValidateFolderResponse(folders, folderId, displayName, description, FolderDtoProvisionType.Automatic, FolderDtoPermissionModel.FineGrained);
                }

                using (var cmdlet = PowershellFactory.CreateCmdlet(runspace))
                {
                    var updatedDisplayName = TestRandom.RandomString();
                    cmdlet.AddCommand(UiPathStrings.EditFolder)
                    .AddArgument(currentFolder)
                    .AddParameter(UiPathStrings.DisplayName, updatedDisplayName);
                    Invoke <Folder>(cmdlet);
                }

                using (var cmdlet = PowershellFactory.CreateCmdlet(runspace))
                {
                    cmdlet.AddCommand(UiPathStrings.RemoveFolder)
                    .AddParameter(UiPathStrings.Id, folderId);
                    Invoke(cmdlet);
                }

                using (var cmdlet = PowershellFactory.CreateCmdlet(runspace))
                {
                    cmdlet.AddCommand(UiPathStrings.GetFolder)
                    .AddParameter(UiPathStrings.DisplayName, displayName);
                    var folders = Invoke <Folder>(cmdlet);
                    Validators.ValidatEmptyResponse(folders);
                }
            }
        }
Exemplo n.º 5
0
        public void UserAddGetRemove()
        {
            using (var runspace = PowershellFactory.CreateAuthenticatedSession(TestContext))
            {
                User        user     = default(User);
                var         userName = TestRandom.RandomAlphaNumeric();
                var         password = TestRandom.RandomPassword();
                var         name     = TestRandom.RandomString();
                var         surname  = TestRandom.RandomString();
                var         email    = TestRandom.RandomEmail();
                UserDtoType userType = UserDtoType.User;

                using (var cmdlet = PowershellFactory.CreateCmdlet(runspace))
                {
                    cmdlet.AddCommand(UiPathStrings.AddUiPathUser)
                    .AddParameter(UiPathStrings.Username, userName)
                    .AddParameter(UiPathStrings.Password, password)
                    .AddParameter(UiPathStrings.Name, name)
                    .AddParameter(UiPathStrings.Surname, surname)
                    .AddParameter(UiPathStrings.EmailAddress, email)
                    .AddParameter(UiPathStrings.Type, userType)
                    .AddParameter(UiPathStrings.RolesList, new List <string>()
                    {
                        UiPathStrings.Administrator
                    });
                    var users = Invoke <User>(cmdlet);
                    Validators.ValidateUserResponse(users, null, userName, password, name, surname, email, userType);
                    user = users[0];
                }

                using (var cmdlet = PowershellFactory.CreateCmdlet(runspace))
                {
                    cmdlet.AddCommand(UiPathStrings.GetUiPathUser)
                    .AddParameter(UiPathStrings.Id, user.Id);
                    var users = Invoke <User>(cmdlet);
                    Validators.ValidateUserResponse(users, user.Id, userName, password, name, surname, email, userType);
                }

                using (var cmdlet = PowershellFactory.CreateCmdlet(runspace))
                {
                    cmdlet.AddCommand(UiPathStrings.RemoveUiPathUser)
                    .AddParameter(UiPathStrings.Id, user.Id);
                    Invoke(cmdlet);
                }

                using (var cmdlet = PowershellFactory.CreateCmdlet(runspace))
                {
                    cmdlet.AddCommand(UiPathStrings.GetUiPathUser)
                    .AddParameter(UiPathStrings.Username, userName);
                    var users = Invoke <User>(cmdlet);
                    Validators.ValidatEmptyResponse(users);
                }
            }
        }
Exemplo n.º 6
0
        public void RobotAddGetRemove()
        {
            using (var runspace = PowershellFactory.CreateAuthenticatedSession(TestContext))
            {
                var  name        = TestRandom.RandomString();
                var  description = TestRandom.RandomString();
                var  licenseKey  = Guid.NewGuid();
                var  machine     = TestRandom.RandomString();
                var  username    = TestRandom.RandomString();
                long?robotId     = null;

                using (var cmdlet = PowershellFactory.CreateCmdlet(runspace))
                {
                    cmdlet.AddCommand(UiPathStrings.AddUiPathRobot)
                    .AddParameter(UiPathStrings.Name, name)
                    .AddParameter(UiPathStrings.MachineName, machine)
                    .AddParameter(UiPathStrings.Description, description)
                    .AddParameter(UiPathStrings.LicenseKey, licenseKey)
                    .AddParameter(UiPathStrings.Username, username)
                    .AddParameter(UiPathStrings.Type, RobotDtoType.NonProduction);
                    var robots = Invoke <Robot>(cmdlet);

                    Validators.ValidateRobotResponse(robots, null, name, description, machine, licenseKey, RobotDtoType.NonProduction);

                    robotId = robots[0].Id;
                }

                using (var cmdlet = PowershellFactory.CreateCmdlet(runspace))
                {
                    cmdlet.AddCommand(UiPathStrings.GetUiPathRobot)
                    .AddParameter(UiPathStrings.Id, robotId);
                    var robots = Invoke <Robot>(cmdlet);

                    Validators.ValidateRobotResponse(robots, robotId, name, description, machine, licenseKey, RobotDtoType.NonProduction);
                }

                using (var cmdlet = PowershellFactory.CreateCmdlet(runspace))
                {
                    cmdlet.AddCommand(UiPathStrings.RemoveUiPathRobot)
                    .AddParameter(UiPathStrings.Id, robotId);
                    Invoke <Robot>(cmdlet);
                }

                using (var cmdlet = PowershellFactory.CreateCmdlet(runspace))
                {
                    cmdlet.AddCommand(UiPathStrings.GetUiPathRobot)
                    .AddParameter(UiPathStrings.Name, name);
                    var robots = Invoke <Robot>(cmdlet);

                    Validators.ValidatEmptyResponse(robots);
                }
            }
        }
Exemplo n.º 7
0
        public void RoleAddGetRemove()
        {
            using (var runspace = PowershellFactory.CreateAuthenticatedSession(TestContext))
            {
                Role role       = default(Role);
                var  name       = TestRandom.RandomAlphaNumeric();
                var  displaName = TestRandom.RandomString();

                var permissions = new List <string>()
                {
                    "Robots.View",
                    "Robots.Edit",
                    "Robots.Create",
                    "Robots.Delete"
                };

                using (var cmdlet = PowershellFactory.CreateCmdlet(runspace))
                {
                    cmdlet.AddCommand(UiPathStrings.AddUiPathRole)
                    .AddParameter(UiPathStrings.Name, name)
                    //.AddParameter(UiPathStrings.DisplayName, displaName)  -- bugbug: the displayname is ignored by Orchestrator
                    .AddParameter(UiPathStrings.IsEditable)
                    .AddParameter(UiPathStrings.Permissions, permissions);
                    var roles = Invoke <Role>(cmdlet);
                    Validators.ValidateRoleResult(roles, null, name, name, true, false, null);
                    role = roles[0];
                }

                using (var cmdlet = PowershellFactory.CreateCmdlet(runspace))
                {
                    cmdlet.AddCommand(UiPathStrings.GetUiPathRole)
                    .AddParameter(UiPathStrings.Name, role.Name);
                    var roles = Invoke <Role>(cmdlet);
                    Validators.ValidateRoleResult(roles, role.Id, name, name, true, false, permissions);
                }

                using (var cmdlet = PowershellFactory.CreateCmdlet(runspace))
                {
                    cmdlet.AddCommand(UiPathStrings.RemoveUiPathRole)
                    .AddParameter(UiPathStrings.Id, role.Id);
                    Invoke(cmdlet);
                }

                using (var cmdlet = PowershellFactory.CreateCmdlet(runspace))
                {
                    cmdlet.AddCommand(UiPathStrings.GetUiPathRole)
                    .AddParameter(UiPathStrings.Name, role.Name);
                    var roles = Invoke <Role>(cmdlet);
                    Validators.ValidatEmptyResponse(roles);
                }
            }
        }
Exemplo n.º 8
0
        public void QueueDefinitionAddEditGetRemove()
        {
            using (var runspace = PowershellFactory.CreateAuthenticatedSession(TestContext))
            {
                QueueDefinition queue       = null;
                var             name        = TestRandom.RandomString();
                var             description = TestRandom.RandomString();

                using (var cmdlet = PowershellFactory.CreateCmdlet(runspace))
                {
                    cmdlet.AddCommand(UiPathStrings.AddUiPathQueueDefinition)
                    .AddParameter(UiPathStrings.Name, name)
                    .AddParameter(UiPathStrings.Description, description)
                    .AddParameter(UiPathStrings.AcceptAutomaticallyRetry);
                    var queues = Invoke <QueueDefinition>(cmdlet);

                    Validators.ValidateQueueDefinitionResponse(queues, null, name, description, true, false, 0);

                    queue = queues[0];
                }

                // Positional Get
                using (var cmdlet = PowershellFactory.CreateCmdlet(runspace))
                {
                    description = TestRandom.RandomString();
                    cmdlet.AddCommand(UiPathStrings.EditUiPathQueueDefinition)
                    .AddArgument(queue)
                    .AddParameter(UiPathStrings.Description, description);
                    Invoke <QueueDefinition>(cmdlet);
                }

                using (var cmdlet = PowershellFactory.CreateCmdlet(runspace))
                {
                    cmdlet.AddCommand(UiPathStrings.GetUiPathQueueDefinition)
                    .AddParameter(UiPathStrings.Id, queue.Id);
                    var queues = Invoke <QueueDefinition>(cmdlet);

                    Validators.ValidateQueueDefinitionResponse(queues, queue.Id, name, description, true, false, 0);
                }

                using (var cmdlet = PowershellFactory.CreateCmdlet(runspace))
                {
                    cmdlet.AddCommand(UiPathStrings.RemoveUiPathQueueDefinition)
                    .AddParameter(UiPathStrings.QueueDefinition, queue);
                    Invoke(cmdlet);
                }
            }
        }
        public void AssetAddGetRemoveById()
        {
            using (var runspace = PowershellFactory.CreateAuthenticatedSession(TestContext))
            {
                var  assetName  = TestRandom.RandomString();
                var  assetValue = TestRandom.RandomString();
                long?assetId    = null;
                using (var cmdlet = PowershellFactory.CreateCmdlet(runspace))
                {
                    cmdlet.AddCommand(UiPathStrings.AddUiPathAsset)
                    .AddParameter(UiPathStrings.Name, assetName)
                    .AddParameter(UiPathStrings.TextValue, assetValue);
                    var assets = Invoke <Asset>(cmdlet);

                    Validators.ValidateAssetResponse(assets, null, assetName, AssetDtoValueType.Text, assetValue);

                    assetId = assets[0].Id;
                }

                // Get by name
                using (var cmdlet = PowershellFactory.CreateCmdlet(runspace))
                {
                    cmdlet.AddCommand(UiPathStrings.GetUiPathAsset)
                    .AddParameter(UiPathStrings.Name, assetName);
                    var assets = Invoke <Asset>(cmdlet);
                    Validators.ValidateAssetResponse(assets, assetId, assetName, AssetDtoValueType.Text, assetValue);
                }

                //Remove by Id
                using (var cmdlet = PowershellFactory.CreateCmdlet(runspace))
                {
                    cmdlet.AddCommand(UiPathStrings.RemoveUiPathAsset)
                    .AddParameter(UiPathStrings.Id, assetId);
                    Invoke(cmdlet);
                }

                // Validate is removed
                using (var cmdlet = PowershellFactory.CreateCmdlet(runspace))
                {
                    cmdlet.AddCommand(UiPathStrings.GetUiPathAsset)
                    .AddParameter(UiPathStrings.Name, assetName);
                    var assets = Invoke <Asset>(cmdlet);
                    Validators.ValidatEmptyResponse(assets);
                }
            }
        }
        public void EnvironmentAddGetRemove()
        {
            using (var runspace = PowershellFactory.CreateAuthenticatedSession(TestContext))
            {
                var  name          = TestRandom.RandomString();
                var  description   = TestRandom.RandomString();
                long?environmentId = null;
                using (var cmdlet = PowershellFactory.CreateCmdlet(runspace))
                {
                    cmdlet.AddCommand(UiPathStrings.AddUiPathEnvironment)
                    .AddParameter(UiPathStrings.Name, name)
                    .AddParameter(UiPathStrings.Description, description)
                    .AddParameter(UiPathStrings.Type, EnvironmentDtoType.Dev);
                    var environments = Invoke <Environment>(cmdlet);

                    Validators.ValidateEnvironmentResponse(environments, null, name, description, EnvironmentDtoType.Dev);

                    environmentId = environments[0].Id;
                }

                using (var cmdlet = PowershellFactory.CreateCmdlet(runspace))
                {
                    cmdlet.AddCommand(UiPathStrings.GetUiPathEnvironment)
                    .AddParameter(UiPathStrings.Id, environmentId);
                    var environments = Invoke <Environment>(cmdlet);

                    Validators.ValidateEnvironmentResponse(environments, environmentId, name, description, EnvironmentDtoType.Dev);
                }

                using (var cmdlet = PowershellFactory.CreateCmdlet(runspace))
                {
                    cmdlet.AddCommand(UiPathStrings.RemoveUiPathEnvironment)
                    .AddParameter(UiPathStrings.Id, environmentId);
                    Invoke(cmdlet);
                }

                using (var cmdlet = PowershellFactory.CreateCmdlet(runspace))
                {
                    cmdlet.AddCommand(UiPathStrings.GetUiPathEnvironment)
                    .AddParameter(UiPathStrings.Name, name);
                    var environments = Invoke <Environment>(cmdlet);
                    Validators.ValidatEmptyResponse(environments);
                }
            }
        }
Exemplo n.º 11
0
        public void ScheduleAddRemove()
        {
            using (var runspace = PowershellFactory.CreateAuthenticatedSession(TestContext))
            {
                ProcessSchedule schedule    = null;
                Process         process     = null;
                var             name        = TestRandom.RandomString();
                var             description = TestRandom.RandomString();

                using (var cmdlet = PowershellFactory.CreateCmdlet(runspace))
                {
                    cmdlet.AddCommand(UiPathStrings.GetUiPathProcess)
                    .AddParameter(UiPathStrings.Id, 2);
                    var processes = Invoke <Process>(cmdlet);
                    process = processes[0];
                }

                using (var cmdlet = PowershellFactory.CreateCmdlet(runspace))
                {
                    cmdlet.AddCommand(UiPathStrings.AddUiPathProcessSchedule)
                    .AddParameter(UiPathStrings.Name, name)
                    .AddParameter(UiPathStrings.Process, process)
                    .AddParameter(UiPathStrings.StartProcessCron, TestCron)
                    .AddParameter(UiPathStrings.TimeZoneId, TimeZone.CurrentTimeZone.StandardName)
                    .AddParameter(UiPathStrings.RobotCount, 1);
                    var schedules = Invoke <ProcessSchedule>(cmdlet);

                    schedule = schedules[0];
                }

                using (var cmdlet = PowershellFactory.CreateCmdlet(runspace))
                {
                    cmdlet.AddCommand(UiPathStrings.RemoveUiPathProcessSchedule)
                    .AddParameter(UiPathStrings.Id, schedule.Id);
                    Invoke(cmdlet);
                }
            }
        }
Exemplo n.º 12
0
        public void RobotSettingsSetThenClear()
        {
            using (var runspace = PowershellFactory.CreateAuthenticatedSession(TestContext))
            {
                var     name        = TestRandom.RandomString();
                var     description = TestRandom.RandomString();
                var     machine     = TestRandom.RandomString();
                var     username    = TestRandom.RandomString();
                long?   robotId     = null;
                License license     = null;

                using (var cmdlet = PowershellFactory.CreateCmdlet(runspace))
                {
                    cmdlet.AddCommand(UiPathStrings.GetUiPathLicense);
                    license = Invoke <License>(cmdlet)?.FirstOrDefault();

                    Assert.IsNotNull(license);
                }

                using (var cmdlet = PowershellFactory.CreateCmdlet(runspace))
                {
                    cmdlet.AddCommand(UiPathStrings.AddUiPathRobot)
                    .AddParameter(UiPathStrings.Name, name)
                    .AddParameter(UiPathStrings.MachineName, machine)
                    .AddParameter(UiPathStrings.LicenseKey, license.Code)
                    .AddParameter(UiPathStrings.Description, description)
                    .AddParameter(UiPathStrings.Username, username)
                    .AddParameter(UiPathStrings.Type, RobotDtoType.NonProduction);
                    var robots = Invoke <Robot>(cmdlet);

                    robotId = robots[0].Id;
                }

                using (var cmdlet = PowershellFactory.CreateCmdlet(runspace))
                {
                    cmdlet.AddCommand(UiPathStrings.EditUiPathRobotSettings)
                    .AddParameter(nameof(EditRobotSettings.Id), robotId)
                    .AddParameter(nameof(EditRobotSettings.StudioNotifyServer), false)
                    .AddParameter(nameof(EditRobotSettings.ResolutionHeight), 1920)
                    .AddParameter(nameof(EditRobotSettings.TracingLevel), "Verbose")
                    .AddParameter(nameof(EditRobotSettings.LoginToConsole), true);
                    Invoke <Robot>(cmdlet);
                }

                using (var cmdlet = PowershellFactory.CreateCmdlet(runspace))
                {
                    cmdlet.AddCommand(UiPathStrings.GetUiPathRobotSettings)
                    .AddParameter(UiPathStrings.Id, robotId);
                    var robotSettings = Invoke <RobotExecutionSettings>(cmdlet)?.FirstOrDefault();

                    Assert.IsNotNull(robotSettings);
                    Assert.AreEqual(robotId, robotSettings.Id);
                    Assert.AreEqual(false, robotSettings.StudioNotifyServer);
                    Assert.AreEqual(1920, robotSettings.ResolutionHeight);
                    Assert.AreEqual("Verbose", robotSettings.TracingLevel);
                    Assert.AreEqual(true, robotSettings.LoginToConsole);
                    Assert.IsNull(robotSettings.FontSmoothing);
                    Assert.IsNull(robotSettings.ResolutionWidth);
                    Assert.IsNull(robotSettings.ResolutionDepth);
                }

                using (var cmdlet = PowershellFactory.CreateCmdlet(runspace))
                {
                    cmdlet.AddCommand(UiPathStrings.ClearUiPathRobotSettings)
                    .AddParameter(UiPathStrings.Id, robotId)
                    .AddParameter(nameof(ClearRobotSettings.StudioNotifyServer))
                    .AddParameter(nameof(ClearRobotSettings.TracingLevel))
                    .AddParameter(nameof(ClearRobotSettings.ResolutionHeight))
                    .AddParameter(nameof(ClearRobotSettings.LoginToConsole));
                    Invoke(cmdlet);
                }

                using (var cmdlet = PowershellFactory.CreateCmdlet(runspace))
                {
                    cmdlet.AddCommand(UiPathStrings.GetUiPathRobotSettings)
                    .AddParameter(UiPathStrings.Id, robotId);
                    var robotSettings = Invoke <RobotExecutionSettings>(cmdlet)?.FirstOrDefault();

                    Assert.IsNotNull(robotSettings);
                    Assert.IsNotNull(robotSettings.Id);
                    Assert.IsNull(robotSettings.ResolutionHeight);
                    Assert.IsNull(robotSettings.TracingLevel);
                    Assert.IsNull(robotSettings.LoginToConsole);
                    Assert.IsNull(robotSettings.StudioNotifyServer);
                    Assert.IsNull(robotSettings.FontSmoothing);
                    Assert.IsNull(robotSettings.ResolutionWidth);
                    Assert.IsNull(robotSettings.ResolutionDepth);
                }
            }
        }