public static WorkItemRoot GetWorkItemRoot(EntityService entityService, WorkspaceContext workspaceContext)
{
List <String> fields = new List <String>()
{
Phase.NAME_FIELD
};
EntityListResult <WorkItemRoot> result = entityService.Get <WorkItemRoot>(workspaceContext, null, fields);
WorkItemRoot root = result.data[0];
return(root);
}
public void GetStoryFieldMetadataTest()
{
List <QueryPhrase> queryPhrases = new List <QueryPhrase>();
LogicalQueryPhrase byEntityNamePhrase = new LogicalQueryPhrase(FieldMetadata.ENTITY_NAME_FIELD, "story");
queryPhrases.Add(byEntityNamePhrase);
EntityListResult <FieldMetadata> result = entityService.Get <FieldMetadata>(workspaceContext, queryPhrases, null);
Assert.IsTrue(result.total_count >= 1);
}
private async Task <WorkspaceUser> GetWorkspaceUser()
{
QueryPhrase ownerQuery = new LogicalQueryPhrase("name", user);
EntityListResult <WorkspaceUser> ownerQueryResult = await es.GetAsync <WorkspaceUser>(workspaceContext, ToQueryList(ownerQuery), null);
var workspaceUser = ownerQueryResult.data.FirstOrDefault();
if (workspaceUser == null)
{
throw new Exception($"Unable to find a user with the name \"{user}\"");
}
return(workspaceUser);
}
public static Phase GetPhaseForEntityByLogicalName(EntityService entityService, WorkspaceContext workspaceContext, String entityTypeName, String logicalName)
{
List <QueryPhrase> queryPhrases = new List <QueryPhrase>();
LogicalQueryPhrase byEntityPhrase = new LogicalQueryPhrase(Phase.ENTITY_FIELD, entityTypeName);
LogicalQueryPhrase byNamePhrase = new LogicalQueryPhrase(Phase.LOGICAL_NAME_FIELD, logicalName);
queryPhrases.Add(byEntityPhrase);
queryPhrases.Add(byNamePhrase);
EntityListResult <Phase> result = entityService.Get <Phase>(workspaceContext, queryPhrases, null);
Phase phase = result.data[0];
return(phase);
}
public void CreateGetAndUpdateTest()
{
Defect defect = CreateDefect();
EntityListResult <Defect> list = entityService.Get <Defect>(workspaceContext);
Defect firstDefect = list.data[0];
Defect defectForUpdate = new Defect(firstDefect.Id);
defectForUpdate.SetValue("name", defectForUpdate.Name + " updated " + new Guid());
Defect updatedDefect = entityService.Update <Defect>(workspaceContext, defectForUpdate);
Defect updatedDefect2 = entityService.GetById <Defect>(workspaceContext, firstDefect.Id, null);
Assert.AreEqual(defectForUpdate.Name, updatedDefect2.Name);
}
public async Task <IList <BaseEntity> > GetMyItems()
{
var owner = await GetWorkspaceUser();
EntityListResult <UserItem> userItems = await es.GetAsync <UserItem>(workspaceContext,
BuildUserItemCriteria(owner), BuildUserItemFields());
var collector = new MyWorkEntitiesCollector(this, userItems, MyWorkMetadata.Instance);
List <BaseEntity> result = await collector.GetAllEntities();
result.Sort(EntityComparer);
return(result);
}
public void DefectCoverageTest()
{
Test createdTest1 = TestManualTests.CreateManualTest();
Test createdTest2 = TestManualTests.CreateManualTest();
Test createdTest3 = TestManualTests.CreateManualTest();
Defect createdDefect = DefectTests.CreateDefect();
//create coverage
Defect defectForUpdate = new Defect(createdDefect.Id);
//add tests
EntityList <Test> testList = new EntityList <Test>();
Test testForLink1 = new Test(createdTest1.Id);
testForLink1.TypeName = "test";
testList.data.Add(testForLink1);
Test testForLink2 = new Test(createdTest3.Id);
testForLink2.TypeName = "test";
testList.data.Add(testForLink2);
defectForUpdate.SetValue("test", testList);
//define service arg, its required to add new relation instead of replace existing ones
Dictionary <string, string> serviceArgs = new Dictionary <string, string>();
serviceArgs.Add("reference_update_mode", "append");
//actial update
Defect updated = entityService.Update(workspaceContext, defectForUpdate, serviceArgs, null);
//get test coverage
List <QueryPhrase> queryPhrases = new List <QueryPhrase>();
QueryPhrase defectIdPhrase = new LogicalQueryPhrase(Release.ID_FIELD, createdDefect.Id);
QueryPhrase coveredContentPhrase = new CrossQueryPhrase("covered_content", defectIdPhrase);
queryPhrases.Add(coveredContentPhrase);
EntityListResult <Test> coveredTests = entityService.Get <Test>(workspaceContext, queryPhrases, null);
Assert.AreEqual(2, coveredTests.data.Count);
//validation
List <EntityId> coveredTestIds = coveredTests.data.ConvertAll <EntityId>(a => a.Id);
Assert.IsTrue(coveredTestIds.Contains(testForLink1.Id));
Assert.IsTrue(coveredTestIds.Contains(testForLink2.Id));
}
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;
}
}
private static WorkspaceUser GetWorkspaceUser()
{
QueryPhrase ownerQuery = new LogicalQueryPhrase("name", OctaneConfiguration.Username);
EntityListResult <WorkspaceUser> ownerQueryResult = EntityService.GetAsync <WorkspaceUser>(WorkspaceContext, new List <QueryPhrase> {
ownerQuery
}, null).Result;
var workspaceUser = ownerQueryResult.data.FirstOrDefault();
if (workspaceUser == null)
{
throw new Exception($"Unable to find a user with the name \"{OctaneConfiguration.Username}\"");
}
return(workspaceUser);
}
public void GetCurrentUser()
{
LogicalQueryPhrase byName = new LogicalQueryPhrase(SharedspaceUser.NAME_FIELD, CurrentUserName);
List <QueryPhrase> queries = new List <QueryPhrase>();
queries.Add(byName);
List <String> fields = new List <string> {
SharedspaceUser.NAME_FIELD, SharedspaceUser.WORKSPACE_ROLES_FIELD
};
EntityListResult <SharedspaceUser> users = EntityService.GetInstance().Get <SharedspaceUser>(sharedSpaceContext, queries, fields);
Assert.AreEqual <int>(1, users.total_count.Value);
}
public void GetAllReleasesTest()
{
Release created = CreateRelease();
List <String> fields = new List <string>();
fields.Add(Release.NAME_FIELD);
fields.Add(Release.START_DATE_FIELD);
fields.Add(Release.END_DATE_FIELD);
EntityListResult <Release> result = entityService.Get <Release>(workspaceContext, null, fields);
Assert.IsTrue(result.data.Count >= 1);
}
public void GetMilestonesByReleaseTest()
{
Release release = CreateRelease();
Milestone created1 = CreateMilestone(release);
Milestone created2 = CreateMilestone(release);
List <QueryPhrase> queryPhrases = new List <QueryPhrase>();
QueryPhrase releaseIdPhrase = new LogicalQueryPhrase(Release.ID_FIELD, release.Id);
QueryPhrase byReleasePhrase = new CrossQueryPhrase(Milestone.RELEASE_FIELD, releaseIdPhrase);
queryPhrases.Add(byReleasePhrase);
EntityListResult <Milestone> result = entityService.Get <Milestone>(workspaceContext, queryPhrases, null);
Assert.AreEqual <int>(2, result.data.Count);
}
public void GetOnlyDefectsWithLimit1()
{
List <string> fields = new List <string>();
fields.Add(WorkItem.NAME_FIELD);
fields.Add(WorkItem.SUBTYPE_FIELD);
List <QueryPhrase> queries = new List <QueryPhrase>();
LogicalQueryPhrase subtypeQuery = new LogicalQueryPhrase(WorkItem.SUBTYPE_FIELD, WorkItem.SUBTYPE_DEFECT);
queries.Add(subtypeQuery);
EntityListResult <WorkItem> result = entityService.Get <WorkItem>(workspaceContext, queries, fields, 1);
Assert.IsTrue(result.data.Count <= 1);
}
public void SearchReleases()
{
EntityListResult <Release> searchResult = null;
SpinWait.SpinUntil(() =>
{
Thread.Sleep(1000);
searchResult = entityService.SearchAsync <Release>(workspaceContext, "Release_", null, 2).Result;
return(searchResult.data.Count > 0);
}, new TimeSpan(0, 2, 0));
Assert.IsTrue(searchResult.data.Count > 0);
Assert.IsTrue(searchResult.data.Count <= 2);
}
private void LoadReleases(long sharedSpaceId, long workspaceId)
{
WorkspaceContext context = new WorkspaceContext(sharedSpaceId, workspaceId);
EntityListResult <Release> result = EntityService.GetInstance().Get <Release>(context);
if (result != null)
{
FillCombo <Release>(cmbRelease, result.data);
EnableLoginButton(true);
}
else
{
ClearCombo(cmbRelease);
}
}
public async Task <List <UserItem> > FindUserItemForEntity(BaseEntity baseEntity)
{
var owner = await GetCurrentUser();
EntityListResult <UserItem> userItems = await es.GetAsync <UserItem>(workspaceContext,
BuildFindUserItemCriteria(owner, baseEntity), BuildUserItemFields());
if (userItems.data.Count > 0)
{
return(userItems.data);
}
else
{
return(new List <UserItem>());
}
}
public void SearchStories()
{
EntityListResult <WorkItem> searchResult = null;
SpinWait.SpinUntil(() =>
{
Thread.Sleep(1000);
searchResult = entityService.SearchAsync <WorkItem>(workspaceContext, "story", new List <string> {
WorkItem.SUBTYPE_STORY
}, 10).Result;
return(searchResult.data.Count > 0);
}, new TimeSpan(0, 2, 0));
Assert.IsTrue(searchResult.data.Count > 0);
Assert.IsTrue(searchResult.data.Count <= 10);
}
public void GetReleasesByNameTest()
{
Release release1 = CreateRelease();
Release release2 = CreateRelease();
LogicalQueryPhrase namePhrase = new LogicalQueryPhrase(Release.NAME_FIELD);
namePhrase.AddExpression(release1.Name, ComparisonOperator.Equal);
namePhrase.AddExpression(release2.Name, ComparisonOperator.Equal);
List <QueryPhrase> queryPhrases = new List <QueryPhrase>();
queryPhrases.Add(namePhrase);
EntityListResult <Release> result = entityService.Get <Release>(workspaceContext, queryPhrases, null);
Assert.AreEqual <int>(2, result.data.Count);
}
public EntityListResult<Department> FindStartWith(string deptCode)
{
DepartmentDomain departmentDomain = new DepartmentDomain(1, ATSCommon.Enums.LanguagesEnum.Arabic);
EntityListResult<Department> entityListResult = new EntityListResult<Department>();
try
{
entityListResult.ReturnedEntities = departmentDomain.FindStartWith(deptCode);
if (departmentDomain.ActionState.Status != ATSCommon.Enums.ActionStatusEnum.NoError)
{
entityListResult.Message = departmentDomain.ActionState.Result;
}
}
catch (Exception ex)
{
entityListResult.Message = ex.Message;
}
return entityListResult;
}
public EntityListResult<Employees> FindByDeptCode(string deptCode)
{
EmployeesDomain employeesDomain = new EmployeesDomain(1, ATSCommon.Enums.LanguagesEnum.Arabic);
EntityListResult<Employees> entityListResult = new EntityListResult<Employees>();
try
{
entityListResult.ReturnedEntities = employeesDomain.FindByDeptCode(deptCode);
if (employeesDomain.ActionState.Status != ATSCommon.Enums.ActionStatusEnum.NoError)
{
entityListResult.Message = employeesDomain.ActionState.Result;
}
}
catch (Exception ex)
{
entityListResult.Message = ex.Message;
}
return entityListResult;
}
public EntityListResult<Device> FindAll()
{
DeviceDomain DeviceDomain = new DeviceDomain(1, ATSCommon.Enums.LanguagesEnum.Arabic);
EntityListResult<Device> entityListResult = new EntityListResult<Device>();
try
{
entityListResult.ReturnedEntities = DeviceDomain.FindAll();
if (DeviceDomain.ActionState.Status != ATSCommon.Enums.ActionStatusEnum.NoError)
{
entityListResult.Message = DeviceDomain.ActionState.Result;
}
}
catch (Exception ex)
{
entityListResult.Message = ex.Message;
}
return entityListResult;
}
public static EntityListResult <Milestone> GetMilestonesByRelease(string releaseId)
{
List <String> fields = new List <string>();
fields.Add(Milestone.NAME_FIELD);
fields.Add(Milestone.DATE_FIELD);
fields.Add(Milestone.RELEASE_FIELD);
fields.Add(Milestone.DESCRIPTION_FIELD);
List <QueryPhrase> queryPhrases = new List <QueryPhrase>();
QueryPhrase releaseIdPhrase = new LogicalQueryPhrase("id", releaseId);
QueryPhrase byReleasePhrase = new CrossQueryPhrase(Milestone.RELEASE_FIELD, releaseIdPhrase);
queryPhrases.Add(byReleasePhrase);
EntityListResult <Milestone> result = SettingsForm.EntityService.Get <Milestone>(workspaceContext, queryPhrases, fields);
return(result);
}
public EntityListResult<Company> FindAll()
{
CompanyDomain companyDomain = new CompanyDomain(1, ATSCommon.Enums.LanguagesEnum.Arabic);
EntityListResult<Company> entityListResult = new EntityListResult<Company>();
try
{
entityListResult.ReturnedEntities = companyDomain.FindAll();
if (companyDomain.ActionState.Status != ATSCommon.Enums.ActionStatusEnum.NoError)
{
entityListResult.Message = companyDomain.ActionState.Result;
}
}
catch (Exception ex)
{
entityListResult.Message = ex.Message;
}
return entityListResult;
}
public EntityListResult<Qualifications> FindAll()
{
QualificationsDomain qualificationsDomain = new QualificationsDomain(1, ATSCommon.Enums.LanguagesEnum.Arabic);
EntityListResult<Qualifications> entityListResult = new EntityListResult<Qualifications>();
try
{
entityListResult.ReturnedEntities = qualificationsDomain.FindAll();
if (qualificationsDomain.ActionState.Status != ATSCommon.Enums.ActionStatusEnum.NoError)
{
entityListResult.Message = qualificationsDomain.ActionState.Result;
}
}
catch (Exception ex)
{
entityListResult.Message = ex.Message;
}
return entityListResult;
}
public EntityListResult<Server> FindAll()
{
ServerDomain serverDomain = new ServerDomain(1, ATSCommon.Enums.LanguagesEnum.Arabic);
EntityListResult<Server> entityListResult = new EntityListResult<Server>();
try
{
entityListResult.ReturnedEntities = serverDomain.FindAll();
if (serverDomain.ActionState.Status != ATSCommon.Enums.ActionStatusEnum.NoError)
{
entityListResult.Message = serverDomain.ActionState.Result;
}
}
catch (Exception ex)
{
entityListResult.Message = ex.Message;
}
return entityListResult;
}
public void GetAllSuiteRunTest()
{
CreateSuiteRun();
//get as RunSuite
EntityListResult <RunSuite> runSuites = entityService.Get <RunSuite>(workspaceContext, null, null);
Assert.IsTrue(runSuites.total_count > 0);
//get as run
List <QueryPhrase> queries = new List <QueryPhrase>();
LogicalQueryPhrase byRunSuiteSubType = new LogicalQueryPhrase(Test.SUBTYPE_FIELD, RunSuite.SUBTYPE_RUN_SUITE);
queries.Add(byRunSuiteSubType);
EntityListResult <Run> runSuitesAsRuns = entityService.Get <Run>(workspaceContext, queries, null);
Assert.AreEqual <int?>(runSuites.total_count, runSuitesAsRuns.total_count);
}
public static EntityListResult <Sprint> GetSprintsByRelease(string releaseId)
{
List <String> fields = new List <string>();
fields.Add(Sprint.NAME_FIELD);
fields.Add(Sprint.START_DATE_FIELD);
fields.Add(Sprint.END_DATE_FIELD);
fields.Add(Sprint.RELEASE_FIELD);
List <QueryPhrase> queryPhrases = new List <QueryPhrase>();
QueryPhrase releaseIdPhrase = new LogicalQueryPhrase("id", releaseId);
QueryPhrase byReleasePhrase = new CrossQueryPhrase(Sprint.RELEASE_FIELD, releaseIdPhrase);
queryPhrases.Add(byReleasePhrase);
EntityListResult <Sprint> result = SettingsForm.EntityService.Get <Sprint>(workspaceContext, queryPhrases, fields);
//Release release = result.data[0].Release;
return(result);
}
public static Phase GetPhaseForEntityByName(WorkspaceContext workspaceContext, String entityTypeName, String name)
{
List <QueryPhrase> queryPhrases = new List <QueryPhrase>();
LogicalQueryPhrase byEntityPhrase = new LogicalQueryPhrase(Phase.ENTITY_FIELD, entityTypeName);
LogicalQueryPhrase byNamePhrase = new LogicalQueryPhrase(Phase.NAME_FIELD, name);
queryPhrases.Add(byEntityPhrase);
queryPhrases.Add(byNamePhrase);
List <String> fields = new List <String>()
{
Phase.NAME_FIELD, Phase.LOGICAL_NAME_FIELD
};
EntityListResult <Phase> result = entityService.Get <Phase>(workspaceContext, queryPhrases, fields);
Assert.AreEqual(1, result.total_count);
Phase phase = result.data[0];
return(phase);
}
public void GetAllTestManualTest()
{
CreateManualTest();
//get as testManual
EntityListResult <TestManual> testManuals = entityService.Get <TestManual>(workspaceContext, null, null);
Assert.IsTrue(testManuals.total_count > 0);
//get as test
List <QueryPhrase> queries = new List <QueryPhrase>();
LogicalQueryPhrase byTestManualSubType = new LogicalQueryPhrase(Test.SUBTYPE_FIELD, Test.SUBTYPE_MANUAL_TEST);
queries.Add(byTestManualSubType);
EntityListResult <Test> testManualsAsTests = entityService.Get <Test>(workspaceContext, queries, null);
Assert.AreEqual <int?>(testManuals.total_count, testManualsAsTests.total_count);
}
public void GetAllStories()
{
CreateStory();
//get as stories
EntityListResult <Story> stories = entityService.Get <Story>(workspaceContext, null, null);
Assert.IsTrue(stories.total_count > 0);
//get as work-items
List <QueryPhrase> queries = new List <QueryPhrase>();
LogicalQueryPhrase byStorySubType = new LogicalQueryPhrase(WorkItem.SUBTYPE_FIELD, WorkItem.SUBTYPE_STORY);
queries.Add(byStorySubType);
EntityListResult <WorkItem> storiesAsWorkItems = entityService.Get <WorkItem>(workspaceContext, queries, null);
Assert.AreEqual <int?>(stories.total_count, storiesAsWorkItems.total_count);
}
public static WorkspaceRole GetWorkspaceAdminRole()
{
if (workspaceAdminRole == null)
{
LogicalQueryPhrase logicalNamePhrase = new LogicalQueryPhrase(Role.LOGICAL_NAME_FIELD, WorkspaceRole.WORKSPACE_ADMIN_ROLE_LOGICAL_NAME);
CrossQueryPhrase byRole = new CrossQueryPhrase(WorkspaceRole.ROLE_FIELD, logicalNamePhrase);
LogicalQueryPhrase workspaceIdPhrase = new LogicalQueryPhrase(Workspace.ID_FIELD, workspaceContext.WorkspaceId);
CrossQueryPhrase byWorkpace = new CrossQueryPhrase(WorkspaceRole.WORKSPACE_FIELD, workspaceIdPhrase);
List <QueryPhrase> queries = new List <QueryPhrase>();
queries.Add(byWorkpace);
queries.Add(byRole);
EntityListResult <WorkspaceRole> roles = entityService.Get <WorkspaceRole>(sharedSpaceContext, queries, null);
workspaceAdminRole = roles.data[0];
Assert.AreEqual(WorkspaceRole.WORKSPACE_ADMIN_ROLE_LOGICAL_NAME, workspaceAdminRole.Role.LogicalName);
Assert.AreEqual(workspaceContext.WorkspaceId.ToString(), workspaceAdminRole.Workspace.Id.ToString());
}
return(workspaceAdminRole);
}
public async Task <IActionResult> GetAllbyUserType(int usertype, CancellationToken cancellationToken)
{
var search = Query <UserRole> .Create(x => x.UserType == usertype);
search.IncludeProperties = "User";
var query = new EntityQuery <Core.Data.Entities.UserRole>(search, 1, int.MaxValue, string.Empty);
var result = await ListQuery(query, cancellationToken).ConfigureAwait(false);
var user = _mapper.Map <IEnumerable <UserRoleReadModel>, IEnumerable <UserReadModel> >(result.Data);
var output = new EntityListResult <UserReadModel> {
Total = user.Count(),
Data = user.ToList().AsReadOnly()
};
return(new OkObjectResult(new
{
Data = output,
Status = StatusCodes.Status200OK
}));
}
public void GetNotCompletedDefectsAssinedToReleaseTest()
{
Defect defect = CreateDefect();
Release release = CreateRelease();
//assign defect to release
Defect defectForUpdate = new Defect(defect.Id);
defectForUpdate.Release = release;
entityService.Update <Defect>(workspaceContext, defectForUpdate);
Defect defectAfterUpdate = entityService.GetById <Defect>(workspaceContext, defect.Id, null);
Assert.AreEqual <long>(release.Id, defectAfterUpdate.Release.Id);
//Fetch all defects that assigned to release and still not done
//Fetch defects as work-items
List <QueryPhrase> queries = new List <QueryPhrase>();
LogicalQueryPhrase subtypeQuery = new LogicalQueryPhrase(WorkItem.SUBTYPE_FIELD, WorkItem.SUBTYPE_DEFECT);
queries.Add(subtypeQuery);
//condition of release
QueryPhrase releaseIdPhrase = new LogicalQueryPhrase(WorkItem.ID_FIELD, release.Id);
QueryPhrase byReleasePhrase = new CrossQueryPhrase(WorkItem.RELEASE_FIELD, releaseIdPhrase);
queries.Add(byReleasePhrase);
//condition by metaphase (parent of phase)
LogicalQueryPhrase phaseNamePhrase = new LogicalQueryPhrase(WorkItem.NAME_FIELD, "Done");
phaseNamePhrase.NegativeCondition = true;//not Done
CrossQueryPhrase phaseIdPhrase = new CrossQueryPhrase("metaphase", phaseNamePhrase);
CrossQueryPhrase byPhasePhrase = new CrossQueryPhrase(WorkItem.PHASE_FIELD, phaseIdPhrase);
queries.Add(byPhasePhrase);
EntityListResult <WorkItem> entitiesResult = entityService.Get <WorkItem>(workspaceContext, queries, null);
Assert.AreEqual <int>(1, entitiesResult.total_count.Value);
Assert.AreEqual <long>(defect.Id, entitiesResult.data[0].Id);
}
public void SearchWorkItems()
{
var guid = Guid.NewGuid();
var story = StoryTests.CreateStory("Story_WorkItem_CustomName_" + guid);
var epic = CreateEpic("Epic_WorkItem_CustomName_" + guid);
var feature = CreateFeature(epic, "Feature_WorkItem_CustomName_" + guid);
var defect = DefectTests.CreateDefect("Defect_WorkItem_CustomName_" + guid);
var expectedWorkItems = new List <WorkItem>
{
story, epic, feature
};
EntityListResult <WorkItem> searchResult = null;
SpinWait.SpinUntil(() =>
{
Thread.Sleep(1000);
searchResult = entityService.SearchAsync <WorkItem>(workspaceContext, "_WorkItem_CustomName_" + guid,
new List <string> {
WorkItem.SUBTYPE_STORY, WorkItem.SUBTYPE_EPIC, WorkItem.SUBTYPE_FEATURE
}).Result;
return(searchResult.data.Count == 3);
}, new TimeSpan(0, 2, 0));
Assert.IsNotNull(searchResult, "search operation should have returned something");
Assert.AreEqual(3, searchResult.data.Count, "Mismatched number of entities returned by the search operation");
int actualTestsFoundCount = 0;
foreach (var workItem in expectedWorkItems)
{
actualTestsFoundCount += searchResult.data.Count(t => t.Id == workItem.Id);
}
Assert.AreEqual(searchResult.data.Count, actualTestsFoundCount, "Search request didn't return expected results");
}
public void GetAllRunManualTest()
{
var manualTest = TestManualTests.CreateManualTest();
CreateManualRun(manualTest);
//get as runManual
EntityListResult <RunManual> runManuals = entityService.Get <RunManual>(workspaceContext, null, null);
Assert.IsTrue(runManuals.total_count > 0);
//get as run
List <QueryPhrase> queries = new List <QueryPhrase>();
LogicalQueryPhrase byRunManualSubType = new LogicalQueryPhrase(Test.SUBTYPE_FIELD, RunManual.SUBTYPE_RUN_MANUAL);
queries.Add(byRunManualSubType);
EntityListResult <Run> runManualsAsRuns = entityService.Get <Run>(workspaceContext, queries, null);
Assert.AreEqual <int?>(runManuals.total_count, runManualsAsRuns.total_count);
}
public void AppendSharedSpaceAdminRoleToUserTest()
{
//FIND shared space admin role
LogicalQueryPhrase roleLogicalName = new LogicalQueryPhrase(Role.LOGICAL_NAME_FIELD, "role.shared.space.admin");
CrossQueryPhrase byRole = new CrossQueryPhrase(WorkspaceRole.ROLE_FIELD, roleLogicalName);
List <QueryPhrase> queries = new List <QueryPhrase>();
queries.Add(byRole);
EntityListResult <WorkspaceRole> roles = entityService.Get <WorkspaceRole>(sharedSpaceContext, queries, null);
Assert.AreEqual <int>(1, roles.total_count.Value);
WorkspaceRole sharedSpaceAdminRole = roles.data[0];
//CREATE USER
SharedspaceUser createdUser = CreateUser();
//UPDATE USER by appending shared space admin role
SharedspaceUser userForUpdate = new SharedspaceUser(createdUser.Id);
userForUpdate.WorkspaceRoles = new EntityList <WorkspaceRole>();
userForUpdate.WorkspaceRoles.data.Add(sharedSpaceAdminRole);
Dictionary <String, String> serviceArgs = new Dictionary <string, string>();
serviceArgs.Add("reference_update_mode", "append");
entityService.Update(sharedSpaceContext, userForUpdate, serviceArgs, null);
//READ USER
List <String> fields = new List <string> {
SharedspaceUser.NAME_FIELD, SharedspaceUser.WORKSPACE_ROLES_FIELD
};
SharedspaceUser updatedUser = entityService.GetById <SharedspaceUser>(sharedSpaceContext, createdUser.Id, fields);
List <EntityId> assignedWorkspaceRoles = updatedUser.WorkspaceRoles.data.Select(p => p.Id).ToList();
Assert.IsTrue(assignedWorkspaceRoles.Contains(sharedSpaceAdminRole.Id));
Assert.IsTrue(assignedWorkspaceRoles.Count > 1);
}
