Esempio n. 1
0
        private void LoadWorkspaces(long sharedSpaceId)
        {
            WorkspaceContext   defaultWorkspaceContext = new WorkspaceContext(sharedSpaceId, 1002);
            LogicalQueryPhrase byName  = new LogicalQueryPhrase(WorkspaceUser.NAME_FIELD, txtName.Text);
            List <QueryPhrase> queries = new List <QueryPhrase>();

            queries.Add(byName);

            EntityListResult <WorkspaceUser> users = EntityService.GetInstance().Get <WorkspaceUser>(defaultWorkspaceContext, queries, null);
            long userId = users.data[0].Id;


            SharedSpaceContext context = new SharedSpaceContext(sharedSpaceId);


            LogicalQueryPhrase byUserId = new LogicalQueryPhrase(WorkspaceUser.ID_FIELD, userId);
            CrossQueryPhrase   byUser   = new CrossQueryPhrase(Workspace.USERS_FIELD, byUserId);

            queries = new List <QueryPhrase>();
            queries.Add(byUser);
            EntityListResult <Workspace> workspaces = EntityService.GetInstance().Get <Workspace>(context, queries, null);

            //User user = GetSharedSpaceUser(sharedSpaceId, txtName.Text);

            FillCombo <Workspace>(cmbWorkspace, workspaces.data);
        }
Esempio n. 2
0
        private static WorkspaceContext GetWorkspaceContext(long sharedSpaceId, long workspaceId)
        {
            SharedSpaceContext sharedSpaceContext = new SharedSpaceContext(sharedSpaceId);

            //EntityListResult<Workspace> workspaces = entityService.Get<Workspace>(sharedSpaceContext);
            //Workspace workspace = workspaces.data[0];
            //long workspaceId = 2029;//workspaces.data[0].Id hardcoded workaround
            return(new WorkspaceContext(sharedSpaceId, workspaceId));
        }
Esempio n. 3
0
        public static void AssemblyInitialize(TestContext context)
        {
            // Check if .runsettings is configured properly
            EnsurePropertiesSet(context.Properties,
                                "ignoreServerCertificateValidation",
                                "webAppUrl",
                                "userName",
                                "password",
                                "sharedSpaceId",
                                "workspaceId");

            var ignoreServerCertificateValidation = context.Properties["ignoreServerCertificateValidation"].ToString();

            if (ignoreServerCertificateValidation != null && ignoreServerCertificateValidation.ToLower().Equals("true"))
            {
                NetworkSettings.IgnoreServerCertificateValidation();
            }
            NetworkSettings.EnableAllSecurityProtocols();

            OctaneConfiguration.Url      = context.Properties["webAppUrl"].ToString();
            OctaneConfiguration.Username = context.Properties["userName"].ToString();
            OctaneConfiguration.Password = context.Properties["password"].ToString();

            var connectionInfo = new UserPassConnectionInfo(OctaneConfiguration.Username, OctaneConfiguration.Password);

            RestConnector.Connect(OctaneConfiguration.Url, connectionInfo);

            var sharedSpaceId = int.Parse(context.Properties["sharedSpaceId"].ToString());
            var workspaceId   = int.Parse(context.Properties["workspaceId"].ToString());

            WorkspaceContext = new WorkspaceContext(sharedSpaceId, workspaceId);
            OctaneConfiguration.WorkSpaceId = WorkspaceContext.WorkspaceId;

            var sharedSpaceContext = new SharedSpaceContext(sharedSpaceId);

            OctaneConfiguration.SharedSpaceId = sharedSpaceContext.SharedSpaceId;

            OctaneConfiguration.SsoLogin        = bool.Parse(context.Properties["ssoLogin"].ToString());
            OctaneConfiguration.CredentialLogin = bool.Parse(context.Properties["credentialLogin"].ToString());

            User = GetWorkspaceUser();

            CurrentRelease = ReleaseUtilities.CreateRelease();

            // create the octaneservices object to be used by the tests
            OctaneServices.Create(OctaneConfiguration.Url,
                                  OctaneConfiguration.SharedSpaceId,
                                  OctaneConfiguration.WorkSpaceId);

            OctaneServices.GetInstance().Connect();
        }
 private void LoadWorkspaces(string sharedSpaceId)
 {
     try
     {
         SharedSpaceContext           context    = SharedSpaceContext.Create(sharedSpaceId);
         EntityListResult <Workspace> workspaces = EntityService.Get <Workspace>(context, null, null);
         FillCombo <Workspace>(cmbWorkspace, workspaces.data);
     }
     catch (Exception e)
     {
         lblStatus.Text      = "Failed to load workspaces : " + e.Message;
         lblStatus.ForeColor = Color.Red;
     }
 }
Esempio n. 5
0
        public static void InitConnection(TestContext context)
        {
            if (!restConnector.IsConnected())
            {
                string host     = ConfigurationManager.AppSettings["webAppUrl"];
                string password = ConfigurationManager.AppSettings["password"];
                userName = ConfigurationManager.AppSettings["userName"];
                restConnector.Connect(host, userName, password);


                sharedSpaceId = int.Parse(ConfigurationManager.AppSettings["sharedSpaceId"]);
                workspaceId   = int.Parse(ConfigurationManager.AppSettings["workspaceId"]);

                workspaceContext   = new WorkspaceContext(sharedSpaceId, workspaceId);
                sharedSpaceContext = new SharedSpaceContext(sharedSpaceId);
            }
        }
        public static void InitConnection(TestContext context)
        {
            if (!restConnector.IsConnected())
            {
                string ignoreServerCertificateValidation = ConfigurationManager.AppSettings["ignoreServerCertificateValidation"];
                if (ignoreServerCertificateValidation != null && ignoreServerCertificateValidation.ToLower().Equals("true"))
                {
                    NetworkSettings.IgnoreServerCertificateValidation();
                }
                NetworkSettings.EnableAllSecurityProtocols();

                host = ConfigurationManager.AppSettings["webAppUrl"];

                // If webAppUrl is empty we do not try to connect.
                if (string.IsNullOrWhiteSpace(host))
                {
                    return;
                }

                ConnectionInfo connectionInfo;
                string         clientId = ConfigurationManager.AppSettings["clientId"];
                if (clientId != null)
                {
                    userName       = clientId;
                    connectionInfo = new APIKeyConnectionInfo(clientId, ConfigurationManager.AppSettings["clientSecret"]);
                }
                else
                {
                    userName       = ConfigurationManager.AppSettings["userName"];
                    password       = ConfigurationManager.AppSettings["password"];
                    connectionInfo = new UserPassConnectionInfo(userName, password);
                }

                lwssoAuthenticationStrategy = new LwssoAuthenticationStrategy(connectionInfo);
                restConnector.Connect(host, lwssoAuthenticationStrategy);


                var sharedSpaceId = int.Parse(ConfigurationManager.AppSettings["sharedSpaceId"]);
                var workspaceId   = int.Parse(ConfigurationManager.AppSettings["workspaceId"]);

                workspaceContext   = new WorkspaceContext(sharedSpaceId, workspaceId);
                sharedSpaceContext = new SharedSpaceContext(sharedSpaceId);
            }
        }
        private OctaneServices(string url, long sharedspaceId, long workspaceId)
        {
            this.url = url;

            // create the authentication strategy based on saved configurations
            if (OctaneConfiguration.CredentialLogin)
            {
                authenticationStrategy = new LwssoAuthenticationStrategy(new UserPassConnectionInfo(OctaneConfiguration.Username, OctaneConfiguration.Password));
            }
            else if (OctaneConfiguration.SsoLogin)
            {
                SsoAuthenticationStrategy ssoAuthenticationStrategy = new SsoAuthenticationStrategy();
                ssoAuthenticationStrategy.SetConnectionListener(new SsoConnectionListener());
                authenticationStrategy = ssoAuthenticationStrategy;
            }

            rest = new RestConnector();
            es   = new EntityService(rest);

            workspaceContext   = new WorkspaceContext(sharedspaceId, workspaceId);
            sharedSpaceContext = new SharedSpaceContext(sharedspaceId);
        }