Datasets:
Minata
/
src_fm_fc_ms_ff_method2testcases_v0

Dataset card Data Studio Files Community
1
src_fm_fc_ms_ff
stringlengths
43
86.8k
target
stringlengths
20
276k
XmlUtils { public static XMLInputFactory createBasicInputFactory() { XMLInputFactory xmlFactory = XMLInputFactory.newInstance(); xmlFactory.setProperty(XMLInputFactory.SUPPORT_DTD, false); return xmlFactory; } static XMLInputFactory createBasicInputFactory(); }
@Test public void testCreateBasicInputFactory() throws Exception { XMLInputFactory factory = XmlUtils.createBasicInputFactory(); factory.setXMLResolver(new XMLResolver() { @Override public Object resolveEntity(String publicID, String systemID, String baseURI, String namespace) throws XMLStreamException { Assert.assertFalse("DTD should not be resolved.", "http: return null; } }); XMLStreamReader reader = factory.createXMLStreamReader(new StringReader("<!DOCTYPE foo SYSTEM \"http: while(reader.hasNext()) { reader.next(); } }
ApmUIService { public Entity createRequirementInRelease(String description, String name, String priority, int storyPoints, int releaseId, int sprintId, int teamId, int featureId, int workspaceId) { StringBuffer buf = new StringBuffer(); buf.append("description=").append(EntityQuery.encode(description)); buf.append("&featureID=").append(featureId); buf.append("&name=").append(EntityQuery.encode(name)); buf.append("&parentID=0"); buf.append("&priority=").append(EntityQuery.encode(priority)); buf.append("&releaseId=").append(releaseId); buf.append("&reqType=70"); buf.append("&sprintID=").append(sprintId); buf.append("&storyPoints=").append(storyPoints); buf.append("&teamID=").append(teamId); buf.append("&productGroupId=").append(workspaceId); return createItem("apmuiservices/additemservice/createrequirementinrelease", buf.toString()); } ApmUIService(RestService restService, EntityService entityService, ErrorService errorService); Entity createDefectInRelease(String description, String summary, String severity, String detectedBy, int releaseId, int sprintId, int teamId, int featureId, int workspaceId); Entity createRequirementInRelease(String description, String name, String priority, int storyPoints, int releaseId, int sprintId, int teamId, int featureId, int workspaceId); AuthenticationInfo getAuthenticationInfo(); }
@Test public void testCreateRequirementInRelease() { handler.addRequest("POST", "/qcbin/rest/domains/domain/projects/project/apmuiservices/additemservice/createrequirementinrelease", 200) .expectBody("description=something&featureID=1439&name=somewhat&parentID=0&priority=2-High&releaseId=1001&reqType=70&sprintID=1001&storyPoints=1&teamID=101&productGroupId=1200") .content("apmUIServiceTest_requirement.xml"); RestInvocations.loadMetadata(handler, "project-task"); handler.addRequest("GET", "/qcbin/rest/domains/domain/projects/project/project-tasks?fields=&query={release-backlog-item-id[4289]}&order-by={}", 200) .content("apmUIServiceTest_task.xml"); final LinkedList<EntityCheck> list = new LinkedList<EntityCheck>(); list.add(new EntityCheck() { @Override public void run() { Assert.assertEquals("release-backlog-item", entity.getType()); Assert.assertEquals(4289, entity.getId()); Assert.assertEquals(EntityListener.Event.CREATE, event); } }); list.add(new EntityCheck() { @Override public void run() { Assert.assertEquals("requirement", entity.getType()); Assert.assertEquals(4199, entity.getId()); Assert.assertEquals(EntityListener.Event.CREATE, event); Assert.assertEquals("4289", entity.getPropertyValue("release-backlog-item.id")); } }); list.add(new EntityCheck() { @Override public void run() { Assert.assertEquals("project-task", entity.getType()); Assert.assertEquals(107, entity.getId()); Assert.assertEquals(EntityListener.Event.CREATE, event); } }); addEntityListener(new EntityAdapter() { @Override public void entityLoaded(Entity entity, Event event) { handler.done(list.removeFirst().set(entity, event)); } }); handler.async(3); apmUIService.createRequirementInRelease("something", "somewhat", "2-High", 1, 1001, 1001, 101, 1439, 1200); }
ApmUIService { public Entity createDefectInRelease(String description, String summary, String severity, String detectedBy, int releaseId, int sprintId, int teamId, int featureId, int workspaceId) { StringBuffer buf = new StringBuffer(); buf.append("description=").append(EntityQuery.encode(description)); buf.append("&detectedBy=").append(EntityQuery.encode(detectedBy)); buf.append("&detectedOn="); buf.append("&featureID=").append(featureId > 0? featureId: 0); buf.append("&name=").append(EntityQuery.encode(summary)); buf.append("&releaseId=").append(releaseId); buf.append("&sevirity=").append(EntityQuery.encode(severity)); buf.append("&sprintID=").append(sprintId); buf.append("&teamID=").append(teamId); buf.append("&productGroupId=").append(workspaceId); return createItem("apmuiservices/additemservice/createdefectinrelease", buf.toString()); } ApmUIService(RestService restService, EntityService entityService, ErrorService errorService); Entity createDefectInRelease(String description, String summary, String severity, String detectedBy, int releaseId, int sprintId, int teamId, int featureId, int workspaceId); Entity createRequirementInRelease(String description, String name, String priority, int storyPoints, int releaseId, int sprintId, int teamId, int featureId, int workspaceId); AuthenticationInfo getAuthenticationInfo(); }
@Test public void testCreationFailure() { handler.addRequest("POST", "/qcbin/rest/domains/domain/projects/project/apmuiservices/additemservice/createdefectinrelease", 500) .responseBody("Bad day"); Entity defect = apmUIService.createDefectInRelease("something", "somewhat", "2-High", "me", 1001, 1001, 101, 1439, 1200); Assert.assertNull(defect); checkError("Bad day"); } @Test public void testCreateDefectInRelease() { handler.addRequest("POST", "/qcbin/rest/domains/domain/projects/project/apmuiservices/additemservice/createdefectinrelease", 200) .expectBody("description=something&detectedBy=me&detectedOn=&featureID=1439&name=somewhat&releaseId=1001&sevirity=2-High&sprintID=1001&teamID=101&productGroupId=1200") .content("apmUIServiceTest_defect.xml"); RestInvocations.loadMetadata(handler, "project-task"); handler.addRequest("GET", "/qcbin/rest/domains/domain/projects/project/project-tasks?fields=&query={release-backlog-item-id[4289]}&order-by={}", 200) .content("apmUIServiceTest_task.xml"); final LinkedList<EntityCheck> list = new LinkedList<EntityCheck>(); list.add(new EntityCheck() { @Override public void run() { Assert.assertEquals("release-backlog-item", entity.getType()); Assert.assertEquals(4289, entity.getId()); Assert.assertEquals(EntityListener.Event.CREATE, event); } }); list.add(new EntityCheck() { @Override public void run() { Assert.assertEquals("defect", entity.getType()); Assert.assertEquals(86, entity.getId()); Assert.assertEquals(EntityListener.Event.CREATE, event); Assert.assertEquals("4289", entity.getPropertyValue("release-backlog-item.id")); } }); list.add(new EntityCheck() { @Override public void run() { Assert.assertEquals("project-task", entity.getType()); Assert.assertEquals(107, entity.getId()); Assert.assertEquals(EntityListener.Event.CREATE, event); } }); addEntityListener(new EntityAdapter() { @Override public void entityLoaded(Entity entity, Event event) { handler.done(list.removeFirst().set(entity, event)); } }); handler.async(3); apmUIService.createDefectInRelease("something", "somewhat", "2-High", "me", 1001, 1001, 101, 1439, 1200); }
ApmUIService { public AuthenticationInfo getAuthenticationInfo() { MyResultInfo result = new MyResultInfo(); int code = restService.get(result, "apmuiservices/configurationusers/authentication-info"); if(code == 200) { return new Gson().fromJson(result.getBodyAsString(), AuthenticationInfo.class); } else { errorService.showException(new RestException(result)); return null; } } ApmUIService(RestService restService, EntityService entityService, ErrorService errorService); Entity createDefectInRelease(String description, String summary, String severity, String detectedBy, int releaseId, int sprintId, int teamId, int featureId, int workspaceId); Entity createRequirementInRelease(String description, String name, String priority, int storyPoints, int releaseId, int sprintId, int teamId, int featureId, int workspaceId); AuthenticationInfo getAuthenticationInfo(); }
@Test public void testGetAuthenticationInfo() { handler.addRequest("GET", "/qcbin/rest/domains/domain/projects/project/apmuiservices/configurationusers/authentication-info", 200) .content("apmUIServiceTest_authenticationInfo.json"); AuthenticationInfo authenticationInfo = apmUIService.getAuthenticationInfo(); Assert.assertEquals(1, authenticationInfo.getAssignedWorkspaces().size()); Assert.assertEquals(1000, (int) authenticationInfo.getAssignedWorkspaces().iterator().next()); }
ActiveItemService implements PersistentStateComponent<Element>, TaskManagerIntegration.Listener { public Element getState() { Element element = new Element(getClass().getSimpleName()); if(ref != null) { element.setAttribute("type", ref.type); element.setAttribute("id", String.valueOf(ref.id)); } return element; } ActiveItemService(Project project, DetailUtil detailUtil); synchronized void activate(Entity entity, boolean callTaskManager, boolean select); synchronized EntityRef getActiveItem(); void selectEntityDetail(final Entity entity); void addListener(Listener listener); void removeListener(Listener listener); Element getState(); void loadState(Element state); void taskEntityActivated(Entity entity); static Icon activeItemIcon; }
@Test public void testGetState() { selectDefect(); Element state = activeItemService.getState(); Assert.assertEquals("ActiveItemService", state.getName()); Assert.assertEquals("defect", state.getAttributeValue("type")); Assert.assertEquals("1", state.getAttributeValue("id")); } @Test public void testGetState_none() { selectNothing(); Element state = activeItemService.getState(); Assert.assertEquals("ActiveItemService", state.getName()); Assert.assertNull(state.getAttributeValue("type")); Assert.assertNull(state.getAttributeValue("id")); }
ActiveItemService implements PersistentStateComponent<Element>, TaskManagerIntegration.Listener { public void loadState(Element state) { String type = state.getAttributeValue("type"); if(type != null) { ref = new EntityRef(type, Integer.valueOf(state.getAttributeValue("id"))); } } ActiveItemService(Project project, DetailUtil detailUtil); synchronized void activate(Entity entity, boolean callTaskManager, boolean select); synchronized EntityRef getActiveItem(); void selectEntityDetail(final Entity entity); void addListener(Listener listener); void removeListener(Listener listener); Element getState(); void loadState(Element state); void taskEntityActivated(Entity entity); static Icon activeItemIcon; }
@Test public void testLoadState() { selectNothing(); Element state = new Element("ActiveItemService"); state.setAttribute("type", "defect"); state.setAttribute("id", "2"); activeItemService.loadState(state); checkActivateItem("defect", 2); }
ActiveItemService implements PersistentStateComponent<Element>, TaskManagerIntegration.Listener { public synchronized void activate(Entity entity, boolean callTaskManager, boolean select) { if(entity != null) { ref = new EntityRef(entity); } else { ref = null; } fireOnActivated(); if(select && entity != null) { selectEntityDetail(entity); } if(callTaskManager && taskManagerIntegration != null) { taskManagerIntegration.activate(entity); } } ActiveItemService(Project project, DetailUtil detailUtil); synchronized void activate(Entity entity, boolean callTaskManager, boolean select); synchronized EntityRef getActiveItem(); void selectEntityDetail(final Entity entity); void addListener(Listener listener); void removeListener(Listener listener); Element getState(); void loadState(Element state); void taskEntityActivated(Entity entity); static Icon activeItemIcon; }
@Test public void testActivate() { selectNothing(); handler.async(); activeItemService.addListener(new ActiveItemService.Listener() { @Override public void onActivated(final EntityRef ref) { activeItemService.removeListener(this); handler.done(new Runnable() { @Override public void run() { Assert.assertNotNull(ref); Assert.assertEquals(2, ref.id); Assert.assertEquals("requirement", ref.type); } }); } }); activeItemService.activate(new Entity("requirement", 2), false, false); checkActivateItem("requirement", 2); } @Test public void testActivate_select() { handler.async(); getComponent(DetailUtil.class)._setLauncher(new DetailUtil.Launcher() { @Override public void loadDetail(Project project, final Entity entity, final boolean show, final boolean select) { handler.done(new Runnable() { @Override public void run() { Assert.assertEquals("requirement", entity.getType()); Assert.assertEquals(4, entity.getId()); Assert.assertEquals(true, show); Assert.assertEquals(true, select); } }); } }); activeItemService.activate(new Entity("requirement", 4), false, true); }
ActiveItemService implements PersistentStateComponent<Element>, TaskManagerIntegration.Listener { public void selectEntityDetail(final Entity entity) { ApplicationUtil.invokeLaterIfNeeded(new Runnable() { public void run() { detailUtil.loadDetail(project, entity, true, true); } }); } ActiveItemService(Project project, DetailUtil detailUtil); synchronized void activate(Entity entity, boolean callTaskManager, boolean select); synchronized EntityRef getActiveItem(); void selectEntityDetail(final Entity entity); void addListener(Listener listener); void removeListener(Listener listener); Element getState(); void loadState(Element state); void taskEntityActivated(Entity entity); static Icon activeItemIcon; }
@Test public void testSelectEntityDetail() throws Throwable { handler.async(); getComponent(DetailUtil.class)._setLauncher(new DetailUtil.Launcher() { @Override public void loadDetail(Project project, final Entity entity, final boolean show, final boolean select) { handler.done(new Runnable() { @Override public void run() { Assert.assertEquals("requirement", entity.getType()); Assert.assertEquals(4, entity.getId()); Assert.assertEquals(true, show); Assert.assertEquals(true, select); } }); } }); activeItemService.selectEntityDetail(new Entity("requirement", 4)); }
ProjectListService extends AbstractCachingService<String, Map<Integer, List<String>>, AbstractCachingService.Callback<Map<Integer, List<String>>>> { public List<String> getProjectList(String entityType, Field field) { String relatedType = field.getRelatedType(); List<String> values; if(relatedType != null) { values = getValue(relatedType).get(field.getListId()); } else { values = getValue(entityType).get(field.getListId()); } if(values == null) { return Collections.emptyList(); } else { return values; } } ProjectListService(Project project, RestService restService); List<String> getProjectList(String entityType, Field field); }
@Test public void testGetProjectList() { RestInvocations.loadProjectLists(handler, "defect"); Field field = new Field("reproducible", "Reproducible"); field.setListId(1); List<String> list = projectListService.getProjectList("defect", field); switch (version) { case AGM: Assert.assertEquals(Arrays.asList("Y", "N"), list); break; default: Assert.assertEquals(Arrays.asList("N", "Y"), list); } projectListService.getProjectList("defect", field); } @Test public void testGetProjectList_relatedType() { RestInvocations.loadProjectLists(handler, "defect"); Field field = new Field("defect.reproducible", "Reproducible"); field.setListId(1); List<String> list = projectListService.getProjectList("requirement", field); switch (version) { case AGM: Assert.assertEquals(Arrays.asList("Y", "N"), list); break; default: Assert.assertEquals(Arrays.asList("N", "Y"), list); } } @Test public void testGetProjectList_nonExisting() { RestInvocations.loadProjectLists(handler, "defect"); Field field = new Field("non-existing", "Non-existing"); field.setListId(10000); List<String> list = projectListService.getProjectList("defect", field); Assert.assertTrue(list.isEmpty()); }
AliRestClient implements RestClient { @Override public int put(InputData inputData, ResultInfo result, String template, Object... params) { PutMethod putMethod = createMethod(domain, project, PUT_BUILDER, createRequestEntity(inputData), template, params); setHeaders(putMethod, inputData.getHeaders()); executeHttpMethod(putMethod, result); return result.getHttpStatus(); } private AliRestClient(String location, String domain, String project, String userName, String password, SessionStrategy sessionStrategy); static AliRestClient create(String location, String domain, String project, String userName, String password, SessionStrategy sessionStrategy); @Override void setTimeout(int timeout); @Override void setHttpProxy(String proxyHost, int proxyPort); @Override void setHttpProxyCredentials(String username, String password); @Override String getEncoding(); @Override SessionStrategy getSessionStrategy(); @Override void setEncoding(String encoding); @Override void setDomain(String domain); @Override void setProject(String project); @Override String getDomain(); @Override String getProject(); @Override List<Cookie> getCookies(String cookieName); @Override synchronized void login(); @Override synchronized void logout(); @Override String getForString(String template, Object... params); @Override InputStream getForStream(String template, Object... params); @Override int get(ResultInfo result, String template, Object... params); @Override int put(InputData inputData, ResultInfo result, String template, Object... params); @Override int delete(ResultInfo result, String template, Object... params); @Override int post(InputData data, ResultInfo result, String template, Object... params); @Override List<String> listDomains(); @Override List<String> listCurrentProjects(); static final Set<Integer> AUTH_FAIL_STATUSES; static final int DEFAULT_CLIENT_TIMEOUT; }
@Test public void testPut() { handler.authenticate(); handler.addRequest("PUT", "/qcbin/rest/domains/domain/projects/project/path/arg1/arg2", 200) .expectHeader("header-input", "value-input") .expectBody("input") .responseHeader("header-output", "value-output") .responseBody("output"); AliRestClient client = AliRestClient.create(handler.getQcUrl(), "domain", "project", "user", "password", RestClient.SessionStrategy.AUTO_LOGIN); ResultInfo resultInfo = ResultInfo.create(new ByteArrayOutputStream()); int code = client.put(InputData.create("input", Collections.singletonMap("header-input", "value-input")), resultInfo, "/path/{0}/{1}", "arg1", "arg2"); Assert.assertEquals(200, code); Assert.assertEquals("output", resultInfo.getBodyStream().toString()); Assert.assertEquals("value-output", resultInfo.getHeaders().get("header-output")); }
TeamMemberService extends AbstractCachingEntityService<Entity> { public EntityList getTeamMembers(Entity team) { return getValue(team); } TeamMemberService(Project project, EntityService entityService); EntityList getTeamMembers(Entity team); void getTeamMembersAsync(Entity team, Callback<EntityList> callback); }
@Test public void testGetTeamMembers() { EntityList list = teamMemberService.getTeamMembers(new Entity("team", 101)); checkMembers(list); teamMemberService.getTeamMembers(new Entity("team", 101)); }
TeamMemberService extends AbstractCachingEntityService<Entity> { public void getTeamMembersAsync(Entity team, Callback<EntityList> callback) { getValueAsync(team, callback); } TeamMemberService(Project project, EntityService entityService); EntityList getTeamMembers(Entity team); void getTeamMembersAsync(Entity team, Callback<EntityList> callback); }
@Test public void testGetTeamMembersAsync() { handler.async(); teamMemberService.getTeamMembersAsync(new Entity("team", 101), new NonDispatchTestCallback<EntityList>(handler) { @Override public void evaluate(EntityList list) { checkMembers(list); } }); } @Test public void testGetTeamMembersAsync_dispatch() { handler.async(); teamMemberService.getTeamMembersAsync(new Entity("team", 101), new DispatchTestCallback<EntityList>(handler) { @Override public void evaluate(EntityList list) { checkMembers(list); } }); }
AttachmentService { public String createAttachment(String filename, IndicatingInputStream is, long length, EntityRef parent) { Map<String, String> headers = new HashMap<String, String>(); headers.put("Content-Type", "application/octet-stream"); headers.put("Slug", filename); MyResultInfo result = new MyResultInfo(); if(restService.post(new MyInputData(is, length, headers), result, "{0}s/{1}/attachments", parent.type, parent.id) != HttpStatus.SC_CREATED) { errorService.showException(new RestException(result.getBodyAsString(), result.getLocation())); return null; } else { EntityList list = EntityList.create(result.getBodyAsStream(), true); if(!list.isEmpty()) { Entity entity = list.get(0); entityService.fireEntityLoaded(entity, EntityListener.Event.CREATE); return entity.getPropertyValue("name"); } else { return null; } } } AttachmentService(RestService restService, EntityService entityService, ErrorService errorService); Entity getAttachmentEntity(Entity entity); Entity getAttachmentEntity(String name, EntityRef parent); String createAttachment(String filename, IndicatingInputStream is, long length, EntityRef parent); boolean updateAttachmentContent(String name, EntityRef parent, IndicatingInputStream is, long length, boolean silent); Entity updateAttachmentProperty(String name, EntityRef parent, String propertyName, String propertyValue, boolean silent); void deleteAttachment(String name, EntityRef parent); }
@Test public void testCreateAttachment() throws IOException { handler.addRequest("POST", "/qcbin/rest/domains/domain/projects/project/defects/1/attachments", 201) .expectHeader("Content-Type", "application/octet-stream") .expectHeader("Slug", "logfile.txt") .content("attachmentServiceTest_attachment.xml"); handler.async(); addEntityListener(new EntityLoaded(handler, new EntityLoaded.Listener() { @Override public void evaluate(Entity entity, EntityListener.Event event) { checkAttachment(entity); Assert.assertEquals(EntityListener.Event.CREATE, event); } })); String name = attachmentService.createAttachment("logfile.txt", new IndicatingInputStream(file, null), file.length(), new EntityRef("defect", 1)); Assert.assertEquals("logfile.txt", name); } @Test public void testCreateAttachment_failure() throws IOException { handler.addRequest("POST", "/qcbin/rest/domains/domain/projects/project/defects/1/attachments", 500) .responseBody("Failed"); String name = attachmentService.createAttachment("logfile.txt", new IndicatingInputStream(file, null), file.length(), new EntityRef("defect", 1)); Assert.assertNull(name); checkError("Failed"); }
AttachmentService { public void deleteAttachment(String name, EntityRef parent) { MyResultInfo result = new MyResultInfo(); if(restService.delete(result, "{0}s/{1}/attachments/{2}", parent.type, parent.id, EntityQuery.encode(name)) != HttpStatus.SC_OK) { errorService.showException(new RestException(result)); } else { EntityList list = EntityList.create(result.getBodyAsStream()); if(!list.isEmpty()) { entityService.fireEntityNotFound(new EntityRef(list.get(0)), true); } } } AttachmentService(RestService restService, EntityService entityService, ErrorService errorService); Entity getAttachmentEntity(Entity entity); Entity getAttachmentEntity(String name, EntityRef parent); String createAttachment(String filename, IndicatingInputStream is, long length, EntityRef parent); boolean updateAttachmentContent(String name, EntityRef parent, IndicatingInputStream is, long length, boolean silent); Entity updateAttachmentProperty(String name, EntityRef parent, String propertyName, String propertyValue, boolean silent); void deleteAttachment(String name, EntityRef parent); }
@Test public void testDeleteAttachment() { handler.addRequest("DELETE", "/qcbin/rest/domains/domain/projects/project/defects/1/attachments/logfile.txt", 200) .content("attachmentServiceTest_attachment.xml"); handler.async(); addEntityListener(new EntityNotFound(handler, "attachment", 653, true)); attachmentService.deleteAttachment("logfile.txt", new EntityRef("defect", 1)); } @Test public void testDeleteAttachment_failure() { handler.addRequest("DELETE", "/qcbin/rest/domains/domain/projects/project/defects/1/attachments/logfile.txt", 500) .responseBody("Failed"); attachmentService.deleteAttachment("logfile.txt", new EntityRef("defect", 1)); checkError("Failed"); }
AttachmentService { public Entity updateAttachmentProperty(String name, EntityRef parent, String propertyName, String propertyValue, boolean silent) { Entity attachment = new Entity("attachment", 0); attachment.setProperty(propertyName, propertyValue); String xml = XMLOutputterFactory.getXMLOutputter().outputString(new Document(attachment.toElement(Collections.singleton(propertyName)))); MyResultInfo result = new MyResultInfo(); if(restService.put(xml, result, "{0}s/{1}/attachments/{2}", parent.type, parent.id, EntityQuery.encode(name)) != HttpStatus.SC_OK) { if(!silent) { errorService.showException(new RestException(result)); } return null; } EntityList list = EntityList.create(result.getBodyAsStream(), true); if(!list.isEmpty()) { Entity entity = list.get(0); entityService.fireEntityLoaded(entity, EntityListener.Event.GET); return entity; } else { return null; } } AttachmentService(RestService restService, EntityService entityService, ErrorService errorService); Entity getAttachmentEntity(Entity entity); Entity getAttachmentEntity(String name, EntityRef parent); String createAttachment(String filename, IndicatingInputStream is, long length, EntityRef parent); boolean updateAttachmentContent(String name, EntityRef parent, IndicatingInputStream is, long length, boolean silent); Entity updateAttachmentProperty(String name, EntityRef parent, String propertyName, String propertyValue, boolean silent); void deleteAttachment(String name, EntityRef parent); }
@Test public void testUpdateAttachmentProperty() { handler.addRequest("PUT", "/qcbin/rest/domains/domain/projects/project/defects/1/attachments/logfile.txt", 200) .content("attachmentServiceTest_attachment.xml"); handler.async(); addEntityListener(new EntityLoaded(handler, new EntityLoaded.Listener() { @Override public void evaluate(Entity entity, EntityListener.Event event) { checkAttachment(entity); Assert.assertEquals(EntityListener.Event.GET, event); } })); Entity attachment = attachmentService.updateAttachmentProperty("logfile.txt", new EntityRef("defect", 1), "description", "newValue", false); checkAttachment(attachment); } @Test public void testUpdateAttachmentProperty_fail() { handler.addRequest("PUT", "/qcbin/rest/domains/domain/projects/project/defects/1/attachments/logfile.txt", 500) .responseBody("Failed"); Entity attachment = attachmentService.updateAttachmentProperty("logfile.txt", new EntityRef("defect", 1), "description", "newValue", false); Assert.assertNull(attachment); checkError("Failed"); } @Test public void testUpdateAttachmentProperty_failSilently() { handler.addRequest("PUT", "/qcbin/rest/domains/domain/projects/project/defects/1/attachments/logfile.txt", 500) .responseBody("Failed"); Entity attachment = attachmentService.updateAttachmentProperty("logfile.txt", new EntityRef("defect", 1), "description", "newValue", true); Assert.assertNull(attachment); }
AliRestClient implements RestClient { @Override public List<String> listDomains() { return listValues(createMethod(null, null, GET_BUILDER, null, "domains"), "Domain"); } private AliRestClient(String location, String domain, String project, String userName, String password, SessionStrategy sessionStrategy); static AliRestClient create(String location, String domain, String project, String userName, String password, SessionStrategy sessionStrategy); @Override void setTimeout(int timeout); @Override void setHttpProxy(String proxyHost, int proxyPort); @Override void setHttpProxyCredentials(String username, String password); @Override String getEncoding(); @Override SessionStrategy getSessionStrategy(); @Override void setEncoding(String encoding); @Override void setDomain(String domain); @Override void setProject(String project); @Override String getDomain(); @Override String getProject(); @Override List<Cookie> getCookies(String cookieName); @Override synchronized void login(); @Override synchronized void logout(); @Override String getForString(String template, Object... params); @Override InputStream getForStream(String template, Object... params); @Override int get(ResultInfo result, String template, Object... params); @Override int put(InputData inputData, ResultInfo result, String template, Object... params); @Override int delete(ResultInfo result, String template, Object... params); @Override int post(InputData data, ResultInfo result, String template, Object... params); @Override List<String> listDomains(); @Override List<String> listCurrentProjects(); static final Set<Integer> AUTH_FAIL_STATUSES; static final int DEFAULT_CLIENT_TIMEOUT; }
@Test public void testListDomains() { handler.authenticate(); handler.addRequest("GET", "/qcbin/rest/domains", 200) .responseBody("<Domains>" + " <Domain Name='emea'/>" + " <Domain Name='asia'/>" + " <Domain Name='pacific'/>" + "</Domains>"); AliRestClient client = AliRestClient.create(handler.getQcUrl(), null, null, "user", "password", RestClient.SessionStrategy.AUTO_LOGIN); List<String> domains = client.listDomains(); Assert.assertEquals(Arrays.asList("emea", "asia", "pacific"), domains); }
AttachmentService { public boolean updateAttachmentContent(String name, EntityRef parent, IndicatingInputStream is, long length, boolean silent) { Map<String,String> headers = Collections.singletonMap("Content-Type", "application/octet-stream"); MyResultInfo result = new MyResultInfo(); if(restService.put(new MyInputData(is, length, headers), result, "{0}s/{1}/attachments/{2}", parent.type, parent.id, EntityQuery.encode(name)) != HttpStatus.SC_OK) { if(!silent) { errorService.showException(new RestException(result)); } return false; } else { EntityList list = EntityList.create(result.getBodyAsStream(), true); if(!list.isEmpty()) { entityService.fireEntityLoaded(list.get(0), EntityListener.Event.GET); } return true; } } AttachmentService(RestService restService, EntityService entityService, ErrorService errorService); Entity getAttachmentEntity(Entity entity); Entity getAttachmentEntity(String name, EntityRef parent); String createAttachment(String filename, IndicatingInputStream is, long length, EntityRef parent); boolean updateAttachmentContent(String name, EntityRef parent, IndicatingInputStream is, long length, boolean silent); Entity updateAttachmentProperty(String name, EntityRef parent, String propertyName, String propertyValue, boolean silent); void deleteAttachment(String name, EntityRef parent); }
@Test public void testUpdateAttachmentContent() throws FileNotFoundException { handler.addRequest("PUT", "/qcbin/rest/domains/domain/projects/project/defects/1/attachments/logfile.txt", 200) .expectHeader("Content-Type", "application/octet-stream") .content("attachmentServiceTest_attachment.xml"); handler.async(); addEntityListener(new EntityLoaded(handler, new EntityLoaded.Listener() { @Override public void evaluate(Entity entity, EntityListener.Event event) { checkAttachment(entity); Assert.assertEquals(EntityListener.Event.GET, event); } })); boolean updated = attachmentService.updateAttachmentContent("logfile.txt", new EntityRef("defect", 1), new IndicatingInputStream(file, null), file.length(), false); Assert.assertTrue(updated); } @Test public void testUpdateAttachmentContent_fail() throws FileNotFoundException { handler.addRequest("PUT", "/qcbin/rest/domains/domain/projects/project/defects/1/attachments/logfile.txt", 500) .responseBody("Failed"); boolean updated = attachmentService.updateAttachmentContent("logfile.txt", new EntityRef("defect", 1), new IndicatingInputStream(file, null), file.length(), false); Assert.assertFalse(updated); checkError("Failed"); } @Test public void testUpdateAttachmentContent_failSilently() throws FileNotFoundException { handler.addRequest("PUT", "/qcbin/rest/domains/domain/projects/project/defects/1/attachments/logfile.txt", 500) .responseBody("Failed"); boolean updated = attachmentService.updateAttachmentContent("logfile.txt", new EntityRef("defect", 1), new IndicatingInputStream(file, null), file.length(), true); Assert.assertFalse(updated); }
AttachmentService { public Entity getAttachmentEntity(Entity entity) { if(!"attachment".equals(entity.getType())) { throw new IllegalArgumentException("not an attachment entity"); } return getAttachmentEntity(entity.getPropertyValue("name"), new EntityRef(entity.getPropertyValue("parent-type"), Integer.valueOf(entity.getPropertyValue("parent-id")))); } AttachmentService(RestService restService, EntityService entityService, ErrorService errorService); Entity getAttachmentEntity(Entity entity); Entity getAttachmentEntity(String name, EntityRef parent); String createAttachment(String filename, IndicatingInputStream is, long length, EntityRef parent); boolean updateAttachmentContent(String name, EntityRef parent, IndicatingInputStream is, long length, boolean silent); Entity updateAttachmentProperty(String name, EntityRef parent, String propertyName, String propertyValue, boolean silent); void deleteAttachment(String name, EntityRef parent); }
@Test public void testGetAttachmentEntity() { handler.addRequest("GET", "/qcbin/rest/domains/domain/projects/project/defects/1/attachments/my%20name?alt=application/xml", 200) .content("attachmentServiceTest_attachment.xml"); Entity attachment = new Entity("attachment", 653); attachment.setProperty("name", "my name"); attachment.setProperty("parent-type", "defect"); attachment.setProperty("parent-id", "1"); Entity entity = attachmentService.getAttachmentEntity(attachment); checkAttachment(entity); } @Test public void testGetAttachmentEntity_alternative() { handler.addRequest("GET", "/qcbin/rest/domains/domain/projects/project/defects/1/attachments/my%20name?alt=application/xml", 200) .content("attachmentServiceTest_attachment.xml"); Entity entity = attachmentService.getAttachmentEntity("my name", new EntityRef("defect", 1)); checkAttachment(entity); } @Test public void testGetAttachmentEntity_failure() { handler.addRequest("GET", "/qcbin/rest/domains/domain/projects/project/defects/1/attachments/my%20name?alt=application/xml", 500) .responseBody("Not this time"); Entity entity = attachmentService.getAttachmentEntity("my name", new EntityRef("defect", 1)); Assert.assertNull(entity); checkError("Not this time"); } @Test public void testGetAttachmentEntity_illegal() { Entity defect = new Entity("defect", 1); try { attachmentService.getAttachmentEntity(defect); Assert.fail("should have failed"); } catch (IllegalArgumentException e) { } }
WorkspaceService extends AbstractCachingEntityService<Void> { public void selectWorkspace(int id, String name) { if (!Integer.valueOf(id).equals(workspaceConfiguration.getWorkspaceId())) { workspaceConfiguration.setWorkspaceId(id); workspaceConfiguration.setWorkspaceName(name); restService.fireServerTypeEvent(); } } WorkspaceService(Project project, EntityService entityService, RestService restService, WorkspaceConfiguration workspaceConfiguration); int getWorkspaceId(); String getWorkspaceName(); void selectWorkspace(int id, String name); Map<Integer, String> listWorkspaces(); void listWorkspacesAsync(Callback<Map<Integer, String>> callback); }
@Test public void testSelectWorkspace() throws Throwable { RestInvocations.sprintService_getReleases(handler, 1005); handler.async(); restService.addServerTypeListener(new OneTimeServerTypeListener(handler, restService) { @Override protected void connectedToEvent(ServerType serverType) { Assert.assertEquals(ServerType.AGM, serverType); } }); try { workspaceService.selectWorkspace(1005, "Red"); handler.consume(); Assert.assertEquals(1005, (int) workspaceConfiguration.getWorkspaceId()); Assert.assertEquals(workspaceConfiguration.getWorkspaceName(), "Red"); } finally { workspaceConfiguration.setWorkspaceId(1000); } }
AliRestClient implements RestClient { @Override public List<String> listCurrentProjects() { if (domain == null) { throw new IllegalStateException("domain==null"); } return listValues(createMethod(domain, null, GET_BUILDER, null, "projects"), "Project"); } private AliRestClient(String location, String domain, String project, String userName, String password, SessionStrategy sessionStrategy); static AliRestClient create(String location, String domain, String project, String userName, String password, SessionStrategy sessionStrategy); @Override void setTimeout(int timeout); @Override void setHttpProxy(String proxyHost, int proxyPort); @Override void setHttpProxyCredentials(String username, String password); @Override String getEncoding(); @Override SessionStrategy getSessionStrategy(); @Override void setEncoding(String encoding); @Override void setDomain(String domain); @Override void setProject(String project); @Override String getDomain(); @Override String getProject(); @Override List<Cookie> getCookies(String cookieName); @Override synchronized void login(); @Override synchronized void logout(); @Override String getForString(String template, Object... params); @Override InputStream getForStream(String template, Object... params); @Override int get(ResultInfo result, String template, Object... params); @Override int put(InputData inputData, ResultInfo result, String template, Object... params); @Override int delete(ResultInfo result, String template, Object... params); @Override int post(InputData data, ResultInfo result, String template, Object... params); @Override List<String> listDomains(); @Override List<String> listCurrentProjects(); static final Set<Integer> AUTH_FAIL_STATUSES; static final int DEFAULT_CLIENT_TIMEOUT; }
@Test public void testListCurrentProjects() { handler.authenticate(); handler.addRequest("GET", "/qcbin/rest/domains/emea/projects", 200) .responseBody("<Projects>" + " <Project Name='first'/>" + " <Project Name='second'/>" + " <Project Name='third'/>" + "</Projects>"); AliRestClient client = AliRestClient.create(handler.getQcUrl(), "emea", null, "user", "password", RestClient.SessionStrategy.AUTO_LOGIN); List<String> projects = client.listCurrentProjects(); Assert.assertEquals(Arrays.asList("first", "second", "third"), projects); }
WorkspaceService extends AbstractCachingEntityService<Void> { public Map<Integer, String> listWorkspaces() { return toWorkspaceMap(getValue(null)); } WorkspaceService(Project project, EntityService entityService, RestService restService, WorkspaceConfiguration workspaceConfiguration); int getWorkspaceId(); String getWorkspaceName(); void selectWorkspace(int id, String name); Map<Integer, String> listWorkspaces(); void listWorkspacesAsync(Callback<Map<Integer, String>> callback); }
@Test public void testListWorkspaces() { handler.addRequest(false, "GET", "/qcbin/rest/domains/domain/projects/project/product-groups?fields=&query={}&order-by={}", 200) .content("workspaceServiceTest_workspaces.xml"); Map<Integer, String> map = workspaceService.listWorkspaces(); Assert.assertEquals(3, map.size()); Assert.assertEquals("All", map.get(-1)); Assert.assertEquals("Blue", map.get(1000)); Assert.assertEquals("Green", map.get(1001)); } @Test public void testListWorkspaces_caches() { handler.addRequest(false, "GET", "/qcbin/rest/domains/domain/projects/project/product-groups?fields=&query={}&order-by={}", 200) .content("workspaceServiceTest_workspaces.xml"); workspaceService.listWorkspaces(); Map<Integer, String> map = workspaceService.listWorkspaces(); Assert.assertEquals(3, map.size()); Assert.assertEquals("All", map.get(-1)); Assert.assertEquals("Blue", map.get(1000)); Assert.assertEquals("Green", map.get(1001)); }
WorkspaceService extends AbstractCachingEntityService<Void> { public void listWorkspacesAsync(Callback<Map<Integer, String>> callback) { getValueAsync(null, translate(callback, new Transform<EntityList, Map<Integer, String>>() { @Override public Map<Integer, String> transform(EntityList entities) { return toWorkspaceMap(entities); } })); } WorkspaceService(Project project, EntityService entityService, RestService restService, WorkspaceConfiguration workspaceConfiguration); int getWorkspaceId(); String getWorkspaceName(); void selectWorkspace(int id, String name); Map<Integer, String> listWorkspaces(); void listWorkspacesAsync(Callback<Map<Integer, String>> callback); }
@Test public void testListWorkspacesAsync() { handler.addRequest(false, "GET", "/qcbin/rest/domains/domain/projects/project/product-groups?fields=&query={}&order-by={}", 200) .content("workspaceServiceTest_workspaces.xml"); handler.async(); workspaceService.listWorkspacesAsync(new AbstractCachingService.Callback<Map<Integer, String>>() { @Override public void loaded(final Map<Integer, String> map) { handler.done(new Runnable() { @Override public void run() { Assert.assertEquals(3, map.size()); Assert.assertEquals("All", map.get(-1)); Assert.assertEquals("Blue", map.get(1000)); Assert.assertEquals("Green", map.get(1001)); } }); } }); }
CustomizationService extends AbstractCachingService<Integer, APMCommonSettings, AbstractCachingService.Callback<APMCommonSettings>> { public String getNewDefectStatus(final AbstractCachingService.Callback<String> whenLoaded) { APMCommonSettings settings = getCachedValue(IDE_PREFERENCES); if(settings == null) { getValueAsync(IDE_PREFERENCES, translate(whenLoaded, new Transform<APMCommonSettings, String>() { @Override public String transform(APMCommonSettings settings) { return getNewDefectStatus(settings); } })); return null; } else { return getNewDefectStatus(settings); } } CustomizationService(Project project); String getNewDefectStatus(final AbstractCachingService.Callback<String> whenLoaded); }
@Test public void testGetNewDefectStatus() { handler.async(); String status = customizationService.getNewDefectStatus(new NonDispatchTestCallback<String>(handler) { @Override protected void evaluate(String data) { Assert.assertEquals("New", data); Assert.assertEquals("New", customizationService.getNewDefectStatus(null)); } }); Assert.assertNull(status); customizationService.getNewDefectStatus(new NonDispatchTestCallback<String>(handler) { @Override protected void evaluate(String data) { Assert.assertEquals("New", data); Assert.assertEquals("New", customizationService.getNewDefectStatus(null)); } }); } @Test public void testGetNewDefectStatus_dispatch() { handler.async(); String status = customizationService.getNewDefectStatus(new DispatchTestCallback<String>(handler) { @Override protected void evaluate(String data) { Assert.assertEquals("New", data); Assert.assertEquals("New", customizationService.getNewDefectStatus(null)); } }); Assert.assertNull(status); customizationService.getNewDefectStatus(new DispatchTestCallback<String>(handler) { @Override protected void evaluate(String data) { Assert.assertEquals("New", data); Assert.assertEquals("New", customizationService.getNewDefectStatus(null)); } }); }
ThemeFeatureService extends AbstractCachingEntityService<ThemeFeatureService.Type> { public EntityList getFeatures() { return getValue(Type.feature); } ThemeFeatureService(Project project, EntityService entityService); EntityList getFeatures(); EntityList getFeatures(String filter); EntityList getThemes(); EntityList getThemes(String filter); }
@Test public void testGetFeatures() { handler.addRequest("GET", "/qcbin/rest/domains/domain/projects/project/requirements?fields=id,name,release-backlog-item.id,release-backlog-item.blocked,product-group-id&query={type-id[71]; product-group-id[1000]}&order-by={name[ASC]}&page-size=1000", 200) .content("themeFeatureServiceTest_features.xml"); EntityList list = themeFeatureService.getFeatures(); Assert.assertEquals(2, list.size()); Assert.assertEquals("Feature Due", list.get(0).getPropertyValue("name")); Assert.assertEquals("Feature Uno", list.get(1).getPropertyValue("name")); themeFeatureService.getFeatures(); } @Test public void testGetFeatures_filter() { handler.addRequest("GET", "/qcbin/rest/domains/domain/projects/project/requirements?fields=id,name,release-backlog-item.id,release-backlog-item.blocked,product-group-id&query={type-id[71]; name[Uno]; product-group-id[1000]}&order-by={name[ASC]}&page-size=1000", 200) .content("themeFeatureServiceTest_features2.xml"); EntityList list = themeFeatureService.getFeatures("Uno"); Assert.assertEquals(1, list.size()); Assert.assertEquals("Feature Uno", list.get(0).getPropertyValue("name")); }
ThemeFeatureService extends AbstractCachingEntityService<ThemeFeatureService.Type> { public EntityList getThemes() { return getValue(Type.theme); } ThemeFeatureService(Project project, EntityService entityService); EntityList getFeatures(); EntityList getFeatures(String filter); EntityList getThemes(); EntityList getThemes(String filter); }
@Test public void testGetThemes() { handler.addRequest("GET", "/qcbin/rest/domains/domain/projects/project/requirements?fields=id,name,release-backlog-item.id,release-backlog-item.blocked,product-group-id&query={type-id[72]; product-group-id[1000]}&order-by={name[ASC]}&page-size=1000", 200) .content("themeFeatureServiceTest_themes.xml"); EntityList list = themeFeatureService.getThemes(); Assert.assertEquals(2, list.size()); Assert.assertEquals("Theme Due", list.get(0).getPropertyValue("name")); Assert.assertEquals("Theme Uno", list.get(1).getPropertyValue("name")); themeFeatureService.getThemes(); } @Test public void testGetThemes_filter() { handler.addRequest("GET", "/qcbin/rest/domains/domain/projects/project/requirements?fields=id,name,release-backlog-item.id,release-backlog-item.blocked,product-group-id&query={type-id[72]; name[Uno]; product-group-id[1000]}&order-by={name[ASC]}&page-size=1000", 200) .content("themeFeatureServiceTest_themes2.xml"); EntityList list = themeFeatureService.getThemes("Uno"); Assert.assertEquals(1, list.size()); Assert.assertEquals("Theme Uno", list.get(0).getPropertyValue("name")); }
RequirementTypeService extends AbstractCachingService<Integer, RequirementTypeList, AbstractCachingService.Callback<RequirementTypeList>> { public RequirementTypeList getRequirementTypes() { return getValue(1); } RequirementTypeService(Project project); RequirementTypeList getRequirementTypes(); RequirementTypeList tryRequirementTypes(); void loadRequirementTypeListAsync(Callback<RequirementTypeList> callback); }
@Test public void testGetRequirementTypes() { RestInvocations.loadRequirementTypes(handler); RequirementTypeList types = requirementTypeService.getRequirementTypes(); checkTypes(types); requirementTypeService.getRequirementTypes(); }
MyResultInfo { public void copyFrom(ResultInfo info) { headers.putAll(info.getHeaders()); location = info.getLocation(); } MyResultInfo(); MyResultInfo(IndicatingOutputStream ios); OutputStream getOutputStream(); String getBodyAsString(); InputStream getBodyAsStream(); void copyFrom(ResultInfo info); String getLocation(); Map<String, String> getHeaders(); }
@Test public void testCopyFrom() throws IOException { ResultInfo result = ResultInfo.create(new ByteArrayOutputStream()); result.setLocation("location"); result.getHeaders().put("a", "b"); result.getHeaders().put("c", "d"); MyResultInfo info = new MyResultInfo(); info.copyFrom(result); Assert.assertEquals(result.getHeaders(), info.getHeaders()); Assert.assertEquals(result.getLocation(), info.getLocation()); }
RequirementTypeService extends AbstractCachingService<Integer, RequirementTypeList, AbstractCachingService.Callback<RequirementTypeList>> { public RequirementTypeList tryRequirementTypes() { return getCachedValue(1); } RequirementTypeService(Project project); RequirementTypeList getRequirementTypes(); RequirementTypeList tryRequirementTypes(); void loadRequirementTypeListAsync(Callback<RequirementTypeList> callback); }
@Test public void testTryRequirementTypes() { RequirementTypeList types = requirementTypeService.tryRequirementTypes(); Assert.assertNull(types); RestInvocations.loadRequirementTypes(handler); requirementTypeService.getRequirementTypes(); types = requirementTypeService.tryRequirementTypes(); checkTypes(types); }
RequirementTypeService extends AbstractCachingService<Integer, RequirementTypeList, AbstractCachingService.Callback<RequirementTypeList>> { public void loadRequirementTypeListAsync(Callback<RequirementTypeList> callback) { getValueAsync(1, callback); } RequirementTypeService(Project project); RequirementTypeList getRequirementTypes(); RequirementTypeList tryRequirementTypes(); void loadRequirementTypeListAsync(Callback<RequirementTypeList> callback); }
@Test public void testLoadRequirementTypeList() throws InterruptedException { RestInvocations.loadRequirementTypes(handler); handler.async(); requirementTypeService.loadRequirementTypeListAsync(new NonDispatchTestCallback<RequirementTypeList>(handler) { @Override public void evaluate(RequirementTypeList types) { checkTypes(types); } }); } @Test public void testLoadRequirementTypeList_dispatch() throws InterruptedException { RestInvocations.loadRequirementTypes(handler); handler.async(); requirementTypeService.loadRequirementTypeListAsync(new DispatchTestCallback<RequirementTypeList>(handler) { @Override public void evaluate(RequirementTypeList types) { checkTypes(types); } }); }
EntityReferenceTranslator implements Translator { @Override public String translate(String value, ValueCallback callback) { return new Execution(callback).perform(value); } EntityReferenceTranslator(Project project, String targetType, SimpleCache cache); @Override String translate(String value, ValueCallback callback); String getTargetType(); }
@Test public void testTranslate() { EntityReferenceTranslator translator = new EntityReferenceTranslator(getProject(), "defect", new SimpleCache()); RestInvocations.loadMetadata(handler, "defect"); RestInvocations.loadMetadata(handler, "release-backlog-item"); handler.addRequest(false, "GET", "/qcbin/rest/domains/domain/projects/project/defects?fields=actual-fix-time,attachment,in-bucket,changeset,build-closed,closing-version,closing-date,dev-comments,id,status,description,detected-by,build-detected,detected-in-rcyc,detected-in-rel,detection-version,creation-time,estimated-fix-time,extended-reference,fixed-on-date,has-change,has-linkage,has-others-linkage,last-modified,planned-closing-ver,priority,user-04,user-03,reproducible,severity,subject,name,user-02,user-01,watch-id,release-backlog-item.product-id,release-backlog-item.owner,release-backlog-item.blocked,release-backlog-item.entity-name,release-backlog-item.entity-type,release-backlog-item.feature-id,release-backlog-item.invested,release-backlog-item.kanban-status-id,release-backlog-item.linked-entities-info,release-backlog-item.no-of-sons,release-backlog-item.kanban-parent-status-id,release-backlog-item.rank,release-backlog-item.release-id,release-backlog-item.entity-id,release-backlog-item.remaining,release-backlog-item.sprint-id,release-backlog-item.status,release-backlog-item.kan-parent-duration,release-backlog-item.story-points,release-backlog-item.kan-status-duration,release-backlog-item.team-id,release-backlog-item.theme-id,release-backlog-item.estimated,release-backlog-item.watch-id,release-backlog-item.id,product-group-id&query={id[86]}&order-by={}", 200) .content("entityServiceTest_entity.xml"); handler.async(); String name = translator.translate("86", new ValueCallback() { @Override public void value(final String value) { handler.done(new Runnable() { @Override public void run() { Assert.assertEquals("somewhat", value); } }); } }); Assert.assertNull(name); } @Test public void testTranslate_cache() { SimpleCache cache = new SimpleCache(); Entity defect = new Entity("defect", 86); defect.setProperty("name", "yes"); cache.add(defect); EntityReferenceTranslator translator = new EntityReferenceTranslator(getProject(), "defect", cache); String name = translator.translate("86", new ValueCallback() { @Override public void value(final String value) { Assert.fail("not expected"); } }); Assert.assertEquals("yes", name); } @Test public void testTranslate_notFound() { EntityReferenceTranslator translator = new EntityReferenceTranslator(getProject(), "defect", new SimpleCache()); RestInvocations.loadMetadata(handler, "defect"); RestInvocations.loadMetadata(handler, "release-backlog-item"); handler.addRequest(false, "GET", "/qcbin/rest/domains/domain/projects/project/defects?fields=actual-fix-time,attachment,in-bucket,changeset,build-closed,closing-version,closing-date,dev-comments,id,status,description,detected-by,build-detected,detected-in-rcyc,detected-in-rel,detection-version,creation-time,estimated-fix-time,extended-reference,fixed-on-date,has-change,has-linkage,has-others-linkage,last-modified,planned-closing-ver,priority,user-04,user-03,reproducible,severity,subject,name,user-02,user-01,watch-id,release-backlog-item.product-id,release-backlog-item.owner,release-backlog-item.blocked,release-backlog-item.entity-name,release-backlog-item.entity-type,release-backlog-item.feature-id,release-backlog-item.invested,release-backlog-item.kanban-status-id,release-backlog-item.linked-entities-info,release-backlog-item.no-of-sons,release-backlog-item.kanban-parent-status-id,release-backlog-item.rank,release-backlog-item.release-id,release-backlog-item.entity-id,release-backlog-item.remaining,release-backlog-item.sprint-id,release-backlog-item.status,release-backlog-item.kan-parent-duration,release-backlog-item.story-points,release-backlog-item.kan-status-duration,release-backlog-item.team-id,release-backlog-item.theme-id,release-backlog-item.estimated,release-backlog-item.watch-id,release-backlog-item.id,product-group-id&query={id[87]}&order-by={}", 200) .content("no_entities.xml"); handler.async(); String name = translator.translate("87", new ValueCallback() { @Override public void value(final String value) { handler.done(new Runnable() { @Override public void run() { Assert.assertEquals("N/A", value); } }); } }); Assert.assertNull(name); } @Test public void testTranslate_cacheNotFound() { SimpleCache cache = new SimpleCache(); cache.addNotFound(new EntityRef("defect", 86)); EntityReferenceTranslator translator = new EntityReferenceTranslator(getProject(), "defect", cache); String name = translator.translate("86", new ValueCallback() { @Override public void value(final String value) { Assert.fail("not expected"); } }); Assert.assertEquals("N/A", name); } @Test public void testTranslate_build() { EntityReferenceTranslator translator = new EntityReferenceTranslator(getProject(), "build-instance", new SimpleCache()); RestInvocations.loadMetadata(handler, "build-instance"); RestInvocations.loadMetadata(handler, "build-type"); handler.addRequest(false, "GET", "/qcbin/rest/domains/domain/projects/project/build-instances?fields=product,category,id,status,build-system-url,type,test-coverage,start-date,description,duration,test-fail,running,label,vts,name,notes,number,qa-status,release,revision,sid,test-skip,status-message,test-ok,timestamp,test-success,version&query={id[4546]}&order-by={}", 200) .content("entity_build.xml"); handler.addRequest(false, "GET", "/qcbin/rest/domains/domain/projects/project/build-types?fields=category,server,id,product,default,defect-filter,description,enabled,last,vts,name,release,sid,version,product-group-id&query={id[110]}&order-by={}", 200) .content("entity_build_type.xml"); handler.async(); String name = translator.translate("4546", new ValueCallback() { @Override public void value(final String value) { handler.done(new Runnable() { @Override public void run() { Assert.assertEquals("myApp #1563", value); } }); } }); Assert.assertNull(name); } @Test public void testTranslate_cachedBuildTypeNotFound() { SimpleCache cache = new SimpleCache(); Entity build = new Entity("build-instance", 4546); build.setProperty("number", "1563"); build.setProperty("type", 110); cache.add(build); cache.addNotFound(new EntityRef("build-type", 110)); EntityReferenceTranslator translator = new EntityReferenceTranslator(getProject(), "build-instance", cache); RestInvocations.loadMetadata(handler, "build-instance"); String name = translator.translate("4546", new ValueCallback() { @Override public void value(final String value) { Assert.fail("not expected"); } }); Assert.assertEquals("N/A #1563", name); } @Test public void testTranslate_changeset() { EntityReferenceTranslator translator = new EntityReferenceTranslator(getProject(), "changeset", new SimpleCache()); RestInvocations.loadMetadata(handler, "changeset"); handler.addRequest(false, "GET", "/qcbin/rest/domains/domain/projects/project/changesets?fields=id,date,owner,changed-file-count,has-defect-linkage,has-linkage,has-requirement-linkage,changed-line-count,description,vts,rev,status-message&query={id[941]}&order-by={}", 200) .content("entity_changeset.xml"); handler.async(); String name = translator.translate("941", new ValueCallback() { @Override public void value(final String value) { handler.done(new Runnable() { @Override public void run() { Assert.assertEquals("2012-07-12 04:10:09 dev@null: Fixing something", value); } }); } }); Assert.assertNull(name); }
MyResultInfo { public String getBodyAsString() { return new String(copy.toByteArray()); } MyResultInfo(); MyResultInfo(IndicatingOutputStream ios); OutputStream getOutputStream(); String getBodyAsString(); InputStream getBodyAsStream(); void copyFrom(ResultInfo info); String getLocation(); Map<String, String> getHeaders(); }
@Test public void testGetBodyAsString() throws IOException { MyResultInfo info = new MyResultInfo(); ResultInfo result = ResultInfo.create(info.getOutputStream()); result.getBodyStream().write("foo".getBytes()); Assert.assertEquals("foo", info.getBodyAsString()); }
EntityReferenceTranslator implements Translator { public String getTargetType() { return targetType; } EntityReferenceTranslator(Project project, String targetType, SimpleCache cache); @Override String translate(String value, ValueCallback callback); String getTargetType(); }
@Test public void testGetTargetType() { EntityReferenceTranslator translator = new EntityReferenceTranslator(getProject(), "defect", new SimpleCache()); Assert.assertEquals("defect", translator.getTargetType()); }
ExpressionResolver implements FilterResolver { @Override public String resolveDisplayValue(String expr, ValueCallback onValue) { Node node = ExpressionParser.parse(expr); String value; SingleValueCallBack callBack = new SingleValueCallBack(onValue); if(resolve(node, translator, callBack, node, new HashSet<Node>(Collections.singleton(node)))) { value = ExpressionBuilder.build(node); callBack.value(value); } else { value = TranslateService.LOADING_MESSAGE; callBack.initValue(value); } return value; } ExpressionResolver(Translator translator); @Override String resolveDisplayValue(String expr, ValueCallback onValue); @Override String toRESTQuery(String value); Translator getTranslator(); }
@Test public void testResolveDisplayValueSync() { ExpressionResolver resolver = new ExpressionResolver(new TranslatorSync()); handler.async(); String value = resolver.resolveDisplayValue("A OR B", new ValueCallback() { @Override public void value(final String value) { handler.done(new Runnable() { @Override public void run() { Assert.assertEquals("(a OR b)", value); } }); } }); Assert.assertEquals("(a OR b)", value); } @Test public void testResolveDisplayValueAsync() { final LinkedList<String> expect = new LinkedList<String>(); ExpressionResolver resolver = new ExpressionResolver(new TranslatorAsync(expect)); expect.add("Loading..."); expect.add("(a OR b)"); handler.async(2); synchronized (expect) { String value = resolver.resolveDisplayValue("A OR B", new ValueCallback() { @Override public void value(final String value) { handler.done(new Runnable() { @Override public void run() { Assert.assertFalse("Unexpected: " + value, expect.isEmpty()); Assert.assertEquals(expect.removeFirst(), value); } }); } }); Assert.assertEquals("Loading...", value); } }
ExpressionResolver implements FilterResolver { @Override public String toRESTQuery(String value) { return value; } ExpressionResolver(Translator translator); @Override String resolveDisplayValue(String expr, ValueCallback onValue); @Override String toRESTQuery(String value); Translator getTranslator(); }
@Test public void testToRESTQuery() { ExpressionResolver resolver = new ExpressionResolver(new TranslatorSync()); Assert.assertEquals("A OR B", resolver.toRESTQuery("A OR B")); }
ExpressionResolver implements FilterResolver { public Translator getTranslator() { return translator; } ExpressionResolver(Translator translator); @Override String resolveDisplayValue(String expr, ValueCallback onValue); @Override String toRESTQuery(String value); Translator getTranslator(); }
@Test public void testGetTranslator() { TranslatorSync translator = new TranslatorSync(); ExpressionResolver resolver = new ExpressionResolver(translator); Assert.assertEquals(translator, resolver.getTranslator()); }
MultipleItemsTranslatedResolver extends MultipleItemsResolver { @Override public String resolveDisplayValue(String value, final ValueCallback onValue) { final Map<String, String> map = new LinkedHashMap<String, String>(); final String[] split = value.split(";"); synchronized (map) { for(final String idStr: split) { if(NO_VALUE.equals(idStr)) { setValue(split, map, idStr, NO_VALUE_DESC, onValue); continue; } String result = translator.translate(idStr, new ValueCallback() { @Override public void value(String value) { setValue(split, map, idStr, value, onValue); } }); if(result != null) { setValue(split, map, idStr, result, onValue); } } String resolvedValue; if(map.size() == split.length) { resolvedValue = resolve(split, map); } else { resolvedValue = "Loading..."; } onValue.value(resolvedValue); return resolvedValue; } } MultipleItemsTranslatedResolver(Translator translator); @Override String resolveDisplayValue(String value, final ValueCallback onValue); }
@Test public void testResolveDisplayValueSync() { MultipleItemsTranslatedResolver resolver = new MultipleItemsTranslatedResolver(new TranslatorSync()); handler.async(); String value = resolver.resolveDisplayValue("A;B C;\"\"", new ValueCallback() { @Override public void value(final String value) { handler.done(new Runnable() { @Override public void run() { Assert.assertEquals("a;b c;(no value)", value); } }); } }); Assert.assertEquals("a;b c;(no value)", value); } @Test public void testResolveDisplayValueAsync() { MultipleItemsTranslatedResolver resolver = new MultipleItemsTranslatedResolver(new TranslatorAsync()); final LinkedList<String> expect = new LinkedList<String>(); expect.add("Loading..."); expect.add("a;b c;(no value)"); handler.async(2); synchronized (expect) { String value = resolver.resolveDisplayValue("A;B C;\"\"", new ValueCallback() { @Override public void value(final String value) { synchronized (expect) { handler.done(new Runnable() { @Override public void run() { Assert.assertEquals(expect.removeFirst(), value); } }); } } }); Assert.assertEquals("Loading...", value); } }
MultipleItemsResolver implements FilterResolver { @Override public String resolveDisplayValue(String value, final ValueCallback onValue) { value = value.replace(NO_VALUE, NO_VALUE_DESC); onValue.value(value); return value; } @Override String resolveDisplayValue(String value, final ValueCallback onValue); @Override String toRESTQuery(String value); static final String NO_VALUE; static final String NO_VALUE_DESC; }
@Test public void testResolveDisplayValue() { handler.async(); String value = resolver.resolveDisplayValue("A;B C;\"\"", new ValueCallback() { @Override public void value(final String value) { handler.done(new Runnable() { @Override public void run() { Assert.assertEquals("A;B C;(no value)", value); } }); } }); Assert.assertEquals("A;B C;(no value)", value); }
MultipleItemsResolver implements FilterResolver { @Override public String toRESTQuery(String value) { LinkedList<String> list = new LinkedList<String>(); for(String item: Arrays.asList(value.split(";"))) { if(NO_VALUE.equals(item)) { list.add(NO_VALUE); } else { list.add("\"" + item + "\""); } } return StringUtils.join(list, " OR "); } @Override String resolveDisplayValue(String value, final ValueCallback onValue); @Override String toRESTQuery(String value); static final String NO_VALUE; static final String NO_VALUE_DESC; }
@Test public void testToRESTQuery() { String value = resolver.toRESTQuery("A;B C;\"\""); Assert.assertEquals("\"A\" OR \"B C\" OR \"\"", value); }
ExpressionParser { public static Node parse(String expr) { Lexer lexer = new Lexer(expr); return matchExpr(lexer); } static Node parse(String expr); }
@Test public void testParseBasics() { ExpressionParser.parse("value"); ExpressionParser.parse("value AND value"); ExpressionParser.parse("value OR value"); ExpressionParser.parse("NOT value"); ExpressionParser.parse("(value)"); ExpressionParser.parse("'my value'"); ExpressionParser.parse("\"my value\""); ExpressionParser.parse("<value"); ExpressionParser.parse("<=value"); ExpressionParser.parse("<>value"); ExpressionParser.parse("=value"); ExpressionParser.parse(">value"); ExpressionParser.parse(">=value"); ExpressionParser.parse("(> A OR (<= \"B C\" AND NOT ='D E'))"); } @Test public void testDontMatchOperatorPrefix() { ExpressionParser.parse("orisprefixnotoperator"); } @Test public void testOperatorPriorityLikeQc() { Node node = ExpressionParser.parse("<a OR >=b AND c"); Assert.assertEquals("((< a OR >= b) AND c)", ExpressionBuilder.build(node)); node = ExpressionParser.parse("<a OR (>=b AND c)"); Assert.assertEquals("(< a OR (>= b AND c))", ExpressionBuilder.build(node)); node = ExpressionParser.parse("<a AND >=b OR c"); Assert.assertEquals("((< a AND >= b) OR c)", ExpressionBuilder.build(node)); node = ExpressionParser.parse("<a AND (>=b OR c)"); Assert.assertEquals("(< a AND (>= b OR c))", ExpressionBuilder.build(node)); node = ExpressionParser.parse("(a AND b AND c) OR (x AND y AND z)"); Assert.assertEquals("(((a AND b) AND c) OR ((x AND y) AND z))", ExpressionBuilder.build(node)); }
MyResultInfo { public InputStream getBodyAsStream() { return new ByteArrayInputStream(copy.toByteArray()); } MyResultInfo(); MyResultInfo(IndicatingOutputStream ios); OutputStream getOutputStream(); String getBodyAsString(); InputStream getBodyAsStream(); void copyFrom(ResultInfo info); String getLocation(); Map<String, String> getHeaders(); }
@Test public void testGetBodyAsStream() throws IOException { MyResultInfo info = new MyResultInfo(); ResultInfo result = ResultInfo.create(info.getOutputStream()); result.getBodyStream().write("foo".getBytes()); Assert.assertEquals("foo", IOUtils.toString(info.getBodyAsStream())); }
ExpressionBuilder { public static String build(Node node) { switch (node.type) { case VALUE: return node.value; case AND: case OR: return "(" + build(node.left) + " " + node.type.getRepr() + " " + build(node.right) + ")"; case NOT: case GT: case GTE: case LT: case LTE: case DIFFERS: case EQ: return node.type.getRepr() + " " + build(node.left); } throw new IllegalStateException("Unexpected node type: "+node.type.name()); } static String build(Node node); }
@Test public void testBuildValue() { String str = ExpressionBuilder.build(new Node("abc")); Assert.assertEquals("abc", str); } @Test public void testBuildAnd() { String str = ExpressionBuilder.build(new Node(Type.AND, new Node("abc"), new Node("def"))); Assert.assertEquals("(abc AND def)", str); } @Test public void testBuildOr() { String str = ExpressionBuilder.build(new Node(Type.OR, new Node("abc"), new Node("def"))); Assert.assertEquals("(abc OR def)", str); } @Test public void testBuildNot() { String str = ExpressionBuilder.build(new Node(Type.NOT, new Node("abc"))); Assert.assertEquals("NOT abc", str); } @Test public void testBuildGt() { String str = ExpressionBuilder.build(new Node(Type.GT, new Node("abc"))); Assert.assertEquals("> abc", str); } @Test public void testBuildGte() { String str = ExpressionBuilder.build(new Node(Type.GTE, new Node("abc"))); Assert.assertEquals(">= abc", str); } @Test public void testBuildLt() { String str = ExpressionBuilder.build(new Node(Type.LT, new Node("abc"))); Assert.assertEquals("< abc", str); } @Test public void testBuildLte() { String str = ExpressionBuilder.build(new Node(Type.LTE, new Node("abc"))); Assert.assertEquals("<= abc", str); } @Test public void testBuildDiffers() { String str = ExpressionBuilder.build(new Node(Type.DIFFERS, new Node("abc"))); Assert.assertEquals("<> abc", str); } @Test public void testBuildEq() { String str = ExpressionBuilder.build(new Node(Type.EQ, new Node("abc"))); Assert.assertEquals("= abc", str); } @Test public void testBuildInvalid() { try { ExpressionBuilder.build(new Node(Type.LEFT_P, new Node("abc"))); } catch (Exception e) { Assert.assertEquals("Unexpected node type: LEFT_P", e.getMessage()); } }
IndicatingInputStream extends FileInputStream { public int read() throws IOException { cancel(); int i = super.read(); if(i != -1) { for(OutputStream observer: observers) { observer.write(i); } report(1); } return i; } IndicatingInputStream(File file, ProgressIndicator indicator); void addObserver(OutputStream observer); int read(); int read(byte[] bytes); int read(byte[] bytes, int ofs, int len); }
@Test public void testReporting() throws IOException { final LinkedList<Double> fractions = new LinkedList<Double>(); fractions.add(0.25); fractions.add(0.75); fractions.add(0.80); fractions.add(1.0); handler.async(4); IndicatingInputStream iis = new IndicatingInputStream(file, new ProgressIndicatorBase() { @Override public void setFraction(final double fraction) { handler.done(new Runnable() { @Override public void run() { Assert.assertEquals(fractions.removeFirst(), (Double)fraction); } }); } }); byte[] buf = new byte[10]; Assert.assertEquals(5, iis.read(buf, 0, 5)); Assert.assertEquals(10, iis.read(buf)); Assert.assertEquals('5', iis.read()); Assert.assertEquals(4, iis.read(buf)); }
TranslateService implements ServerTypeListener { public String translateAsync(Field field, final String value, boolean syncCall, final ValueCallback onValue) { return translateAsync(getTranslator(field), value, syncCall, onValue); } TranslateService(Project project, RestService restService); boolean isTranslated(Field field); String convertQueryModelToREST(Field field, String value); String convertQueryModelToView(Field field, String value, ValueCallback callback); FilterResolver getFilterResolver(Field field); Translator getTranslator(Field field); Translator getReferenceTranslator(String targetType); String translateAsync(Field field, final String value, boolean syncCall, final ValueCallback onValue); String translateAsync(Translator translator, final String value, boolean syncCall, final ValueCallback onValue); @Override void connectedTo(ServerType serverType); static final String LOADING_MESSAGE; static final String NA_TOKEN; }
@Test public void testTranslateAsync() { handler.async(); String value = translateService.translateAsync(new TranslatorAsync(), "VALUE", false, new ValueCallback() { @Override public void value(final String value) { handler.done(new Runnable() { @Override public void run() { Assert.assertTrue("Callback outside dispatch thread", SwingUtilities.isEventDispatchThread()); Assert.assertEquals("value", value); } }); } }); Assert.assertEquals("Loading...", value); } @Test public void testTranslateAsync_sync() { String value = translateService.translateAsync(new TranslatorSync(), "VALUE", false, new ValueCallback() { @Override public void value(String value) { Assert.fail("Not expected"); } }); Assert.assertEquals("value", value); } @Test public void testTranslateAsync_syncCallback() { handler.async(); String value = translateService.translateAsync(new TranslatorSync(), "VALUE", true, new ValueCallback() { @Override public void value(final String value) { handler.done(new Runnable() { @Override public void run() { Assert.assertEquals("value", value); } }); } }); Assert.assertEquals("value", value); } @Test public void testTranslateAsync_empty() { handler.async(); String value = translateService.translateAsync(new TranslatorAsync(), "", true, new ValueCallback() { @Override public void value(final String value) { handler.done(new Runnable() { @Override public void run() { Assert.assertEquals("", value); } }); } }); Assert.assertEquals("", value); } @Test public void testTranslateAsync_context() { handler.async(); String value = translateService.translateAsync(new ContextTranslator(), "", true, new ValueCallback() { @Override public void value(final String value) { handler.done(new Runnable() { @Override public void run() { Assert.assertTrue("Callback outside dispatch thread", SwingUtilities.isEventDispatchThread()); Assert.assertEquals("foo", value); } }); } }); Assert.assertEquals("Loading...", value); }
TranslateService implements ServerTypeListener { public Translator getReferenceTranslator(String targetType) { return new EntityReferenceTranslator(project, targetType, cache); } TranslateService(Project project, RestService restService); boolean isTranslated(Field field); String convertQueryModelToREST(Field field, String value); String convertQueryModelToView(Field field, String value, ValueCallback callback); FilterResolver getFilterResolver(Field field); Translator getTranslator(Field field); Translator getReferenceTranslator(String targetType); String translateAsync(Field field, final String value, boolean syncCall, final ValueCallback onValue); String translateAsync(Translator translator, final String value, boolean syncCall, final ValueCallback onValue); @Override void connectedTo(ServerType serverType); static final String LOADING_MESSAGE; static final String NA_TOKEN; }
@Test public void testGetReferenceTranslator() { doTestGetReferenceTranslator(true); } @Test public void testGetReferenceTranslator_caches() throws Throwable { doTestGetReferenceTranslator(true); handler.checkpoint(); Translator translator = translateService.getReferenceTranslator("defect"); String value = translator.translate("86", new ValueCallback() { @Override public void value(String value) { Assert.fail("Not expected"); } }); Assert.assertEquals("somewhat", value); }
IndicatingInputStream extends FileInputStream { private void cancel() throws IOException { if(indicator != null && indicator.isCanceled()) { throw new CanceledException(); } } IndicatingInputStream(File file, ProgressIndicator indicator); void addObserver(OutputStream observer); int read(); int read(byte[] bytes); int read(byte[] bytes, int ofs, int len); }
@Test public void testCancel() throws IOException { IndicatingInputStream iis = new IndicatingInputStream(file, new ProgressIndicatorBase() { @Override public void setFraction(final double fraction) { cancel(); } }); byte[] buf = new byte[5]; Assert.assertEquals(5, iis.read(buf)); try { iis.read(buf); Assert.fail("Should have failed"); } catch (CanceledException e) { } Assert.assertEquals("1234\n", new String(buf)); }
TranslateService implements ServerTypeListener { @Override public void connectedTo(ServerType serverType) { if(serverType.isConnected()) { cache.clear(); } } TranslateService(Project project, RestService restService); boolean isTranslated(Field field); String convertQueryModelToREST(Field field, String value); String convertQueryModelToView(Field field, String value, ValueCallback callback); FilterResolver getFilterResolver(Field field); Translator getTranslator(Field field); Translator getReferenceTranslator(String targetType); String translateAsync(Field field, final String value, boolean syncCall, final ValueCallback onValue); String translateAsync(Translator translator, final String value, boolean syncCall, final ValueCallback onValue); @Override void connectedTo(ServerType serverType); static final String LOADING_MESSAGE; static final String NA_TOKEN; }
@Test public void testGetReferenceTranslator_invalidatesCache() throws Throwable { doTestGetReferenceTranslator(true); handler.checkpoint(); translateService.connectedTo(ServerType.AGM); doTestGetReferenceTranslator(false); }
TranslateService implements ServerTypeListener { public Translator getTranslator(Field field) { if(Type.class.isAssignableFrom(field.getClazz())) { Type type = (Type)project.getComponent(field.getClazz()); Translator translator = type.getTranslator(); if(translator != null) { return translator; } } if(field.getReferencedType() != null) { return getReferenceTranslator(field.getReferencedType()); } return null; } TranslateService(Project project, RestService restService); boolean isTranslated(Field field); String convertQueryModelToREST(Field field, String value); String convertQueryModelToView(Field field, String value, ValueCallback callback); FilterResolver getFilterResolver(Field field); Translator getTranslator(Field field); Translator getReferenceTranslator(String targetType); String translateAsync(Field field, final String value, boolean syncCall, final ValueCallback onValue); String translateAsync(Translator translator, final String value, boolean syncCall, final ValueCallback onValue); @Override void connectedTo(ServerType serverType); static final String LOADING_MESSAGE; static final String NA_TOKEN; }
@Test public void testGetTranslator_reference() { Field field = new Field("build-detected", "Detected in build"); field.setReferencedType("build-instance"); Translator translator = translateService.getTranslator(field); Assert.assertTrue(translator instanceof EntityReferenceTranslator); Assert.assertEquals("build-instance", ((EntityReferenceTranslator) translator).getTargetType()); } @Test public void testGetTranslator_type() { Field field = new Field("duration", "Duration"); field.setClazz(BuildDurationType.class); Translator translator = translateService.getTranslator(field); Assert.assertTrue(translator instanceof BuildDurationType); } @Test public void testGetTranslator_none() { Field field = new Field("name", "Name"); field.setClazz(String.class); Translator translator = translateService.getTranslator(field); Assert.assertNull(translator); } @Test public void testGetTranslator_typeNone() { Field field = new Field("status", "Status"); field.setClazz(BuildStatusType.class); Translator translator = translateService.getTranslator(field); Assert.assertNull(translator); }
TranslateService implements ServerTypeListener { public FilterResolver getFilterResolver(Field field) { if(Type.class.isAssignableFrom(field.getClazz())) { Type type = (Type)project.getComponent(field.getClazz()); FilterResolver filterResolver = type.getFilterResolver(); if(filterResolver != null) { return filterResolver; } } if(field.getReferencedType() != null) { return new ExpressionResolver(getReferenceTranslator(field.getReferencedType())); } if(field.getListId() != null) { return new MultipleItemsResolver(); } return null; } TranslateService(Project project, RestService restService); boolean isTranslated(Field field); String convertQueryModelToREST(Field field, String value); String convertQueryModelToView(Field field, String value, ValueCallback callback); FilterResolver getFilterResolver(Field field); Translator getTranslator(Field field); Translator getReferenceTranslator(String targetType); String translateAsync(Field field, final String value, boolean syncCall, final ValueCallback onValue); String translateAsync(Translator translator, final String value, boolean syncCall, final ValueCallback onValue); @Override void connectedTo(ServerType serverType); static final String LOADING_MESSAGE; static final String NA_TOKEN; }
@Test public void testGetFilterResolver_type() { Field field = new Field("duration", "Duration"); field.setClazz(BuildDurationType.class); FilterResolver resolver = translateService.getFilterResolver(field); Assert.assertTrue(resolver instanceof BuildDurationType); } @Test public void testGetFilterResolver_none() { Field field = new Field("name", "Name"); field.setClazz(String.class); FilterResolver resolver = translateService.getFilterResolver(field); Assert.assertNull(resolver); } @Test public void testGetFilterResolver_list() { Field field = new Field("severity", "Severity"); field.setListId(299); FilterResolver resolver = translateService.getFilterResolver(field); Assert.assertTrue(resolver instanceof MultipleItemsResolver); }
TranslateService implements ServerTypeListener { public String convertQueryModelToView(Field field, String value, ValueCallback callback) { FilterResolver resolver = getFilterResolver(field); if(resolver != null) { return resolver.resolveDisplayValue(value, callback); } else { callback.value(value); return value; } } TranslateService(Project project, RestService restService); boolean isTranslated(Field field); String convertQueryModelToREST(Field field, String value); String convertQueryModelToView(Field field, String value, ValueCallback callback); FilterResolver getFilterResolver(Field field); Translator getTranslator(Field field); Translator getReferenceTranslator(String targetType); String translateAsync(Field field, final String value, boolean syncCall, final ValueCallback onValue); String translateAsync(Translator translator, final String value, boolean syncCall, final ValueCallback onValue); @Override void connectedTo(ServerType serverType); static final String LOADING_MESSAGE; static final String NA_TOKEN; }
@Test public void testConvertQueryModelToView() { Field field = new Field("status", "Status"); field.setClazz(BuildStatusType.class); handler.async(); String value = translateService.convertQueryModelToView(field, "Success;\"\"", new ValueCallback() { @Override public void value(final String value) { handler.done(new Runnable() { @Override public void run() { Assert.assertEquals("Success;(no value)", value); } }); } }); Assert.assertEquals("Success;(no value)", value); } @Test public void testConvertQueryModelToView_none() { Field field = new Field("name", "Name"); field.setClazz(String.class); handler.async(); String value = translateService.convertQueryModelToView(field, "Success;\"\"", new ValueCallback() { @Override public void value(final String value) { handler.done(new Runnable() { @Override public void run() { Assert.assertEquals("Success;\"\"", value); } }); } }); Assert.assertEquals("Success;\"\"", value); }
IndicatingOutputStream extends FileOutputStream { public void write(int i) throws IOException { cancel(); super.write(i); for(OutputStream observer: observers) { observer.write(i); } report(1); } IndicatingOutputStream(File file, int size, ProgressIndicator indicator); void addObserver(OutputStream observer); void write(int i); void write(byte[] bytes); void write(byte[] bytes, int off, int len); }
@Test public void testReporting() throws IOException { final LinkedList<Double> fractions = new LinkedList<Double>(); fractions.add(0.25); fractions.add(0.75); fractions.add(0.80); fractions.add(1.0); handler.async(4); IndicatingOutputStream ios = new IndicatingOutputStream(file, 20, new ProgressIndicatorBase() { @Override public void setFraction(final double fraction) { handler.done(new Runnable() { @Override public void run() { Assert.assertEquals(fractions.removeFirst(), (Double) fraction); } }); } }); byte[] buf0 = "1234\n".getBytes(); byte[] buf1 = "123456789\n".getBytes(); byte[] buf2 = "678\n".getBytes(); ios.write(buf0); ios.write(buf1); ios.write('5'); ios.write(buf2); ios.close(); Assert.assertEquals("1234\n123456789\n5678\n", FileUtils.readFileToString(file)); }
TranslateService implements ServerTypeListener { public String convertQueryModelToREST(Field field, String value) { FilterResolver resolver = getFilterResolver(field); if(resolver != null) { return resolver.toRESTQuery(value); } else { return value; } } TranslateService(Project project, RestService restService); boolean isTranslated(Field field); String convertQueryModelToREST(Field field, String value); String convertQueryModelToView(Field field, String value, ValueCallback callback); FilterResolver getFilterResolver(Field field); Translator getTranslator(Field field); Translator getReferenceTranslator(String targetType); String translateAsync(Field field, final String value, boolean syncCall, final ValueCallback onValue); String translateAsync(Translator translator, final String value, boolean syncCall, final ValueCallback onValue); @Override void connectedTo(ServerType serverType); static final String LOADING_MESSAGE; static final String NA_TOKEN; }
@Test public void testConvertQueryModelToREST() { Field field = new Field("blocked", "Blocked"); field.setClazz(BacklogBlockedType.class); String value = translateService.convertQueryModelToREST(field, "blocked"); Assert.assertEquals("'**'", value); } @Test public void testConvertQueryModelToREST_none() { Field field = new Field("name", "Name"); field.setClazz(String.class); String value = translateService.convertQueryModelToREST(field, "blocked"); Assert.assertEquals("blocked", value); }
TranslateService implements ServerTypeListener { public boolean isTranslated(Field field) { return getTranslator(field) != null; } TranslateService(Project project, RestService restService); boolean isTranslated(Field field); String convertQueryModelToREST(Field field, String value); String convertQueryModelToView(Field field, String value, ValueCallback callback); FilterResolver getFilterResolver(Field field); Translator getTranslator(Field field); Translator getReferenceTranslator(String targetType); String translateAsync(Field field, final String value, boolean syncCall, final ValueCallback onValue); String translateAsync(Translator translator, final String value, boolean syncCall, final ValueCallback onValue); @Override void connectedTo(ServerType serverType); static final String LOADING_MESSAGE; static final String NA_TOKEN; }
@Test public void isTranslated() { Field field = new Field("duration", "Duration"); field.setClazz(BuildDurationType.class); Assert.assertTrue(translateService.isTranslated(field)); } @Test public void isTranslated_negative() { Field field = new Field("name", "Name"); field.setClazz(String.class); Assert.assertFalse(translateService.isTranslated(field)); }
HpAlmTask extends Task { public boolean isInitialized() { return entity.isComplete() || (entity.isInitialized("name") && hasDateProperties(entity) && entity.isInitialized(getDescriptionField(entity.getType())) && (entity.isInitialized("dev-comments") || entity.isInitialized("comments"))); } HpAlmTask(Project project, Entity entity); boolean isInitialized(); String getId(); String getSummary(); String getDescription(); Comment[] getComments(); Icon getIcon(); TaskType getType(); Date getUpdated(); Date getCreated(); boolean isClosed(); String getCustomIcon(); boolean isIssue(); String getIssueUrl(); static Date parseDate(String dateStr); static String getDescriptionField(String entityType); }
@Test public void testIsInitialized() { Entity entity = new Entity("defect", 1); entity.setProperty("name", "Name..."); entity.setProperty("description", "Description..."); entity.setProperty("dev-comments", "comments..."); entity.setProperty("last-modified", "2012-12-12 12:12:12"); entity.setProperty("creation-time", "2012-12-01"); HpAlmTask task = new HpAlmTask(getProject(), entity); Assert.assertTrue(task.isInitialized()); } @Test public void testIsInitialized_complete() { Entity entity = new Entity("defect", 1); entity.setComplete(true); HpAlmTask task = new HpAlmTask(getProject(), entity); Assert.assertTrue(task.isInitialized()); } @Test public void testIsInitialized_negative() { List<String> required = Arrays.asList("name", "description", "dev-comments", "last-modified", "creation-time"); for(String prop: required) { Entity entity = new Entity("defect", 1); for(String key: required) { if(!key.equals(prop)) { entity.setProperty(key, key); } } HpAlmTask task = new HpAlmTask(getProject(), entity); Assert.assertFalse(task.isInitialized()); } }
HpAlmTask extends Task { public String getId() { return new EntityRef(entity).toString(); } HpAlmTask(Project project, Entity entity); boolean isInitialized(); String getId(); String getSummary(); String getDescription(); Comment[] getComments(); Icon getIcon(); TaskType getType(); Date getUpdated(); Date getCreated(); boolean isClosed(); String getCustomIcon(); boolean isIssue(); String getIssueUrl(); static Date parseDate(String dateStr); static String getDescriptionField(String entityType); }
@Test public void testGetId() { Entity entity = new Entity("defect", 1); HpAlmTask task = new HpAlmTask(getProject(), entity); Assert.assertEquals("defect #1", task.getId()); }
HpAlmTask extends Task { public String getSummary() { return entity.getPropertyValue("name"); } HpAlmTask(Project project, Entity entity); boolean isInitialized(); String getId(); String getSummary(); String getDescription(); Comment[] getComments(); Icon getIcon(); TaskType getType(); Date getUpdated(); Date getCreated(); boolean isClosed(); String getCustomIcon(); boolean isIssue(); String getIssueUrl(); static Date parseDate(String dateStr); static String getDescriptionField(String entityType); }
@Test public void testGetSummary() { Entity entity = new Entity("defect", 1); entity.setProperty("name", "My Name"); HpAlmTask task = new HpAlmTask(getProject(), entity); Assert.assertEquals("My Name", task.getSummary()); }
HpAlmTask extends Task { public String getDescription() { return HTMLAreaField.toPlainText(entity.getPropertyValue(getDescriptionField(entity.getType())), false); } HpAlmTask(Project project, Entity entity); boolean isInitialized(); String getId(); String getSummary(); String getDescription(); Comment[] getComments(); Icon getIcon(); TaskType getType(); Date getUpdated(); Date getCreated(); boolean isClosed(); String getCustomIcon(); boolean isIssue(); String getIssueUrl(); static Date parseDate(String dateStr); static String getDescriptionField(String entityType); }
@Test public void testGetDescription() { Entity entity = new Entity("defect", 1); entity.setProperty("description", "<html><body>This is <b>html</b>.</body></html>"); HpAlmTask task = new HpAlmTask(getProject(), entity); Assert.assertEquals("This is html.", task.getDescription()); }
IndicatingOutputStream extends FileOutputStream { private void cancel() throws IOException { if(indicator != null && indicator.isCanceled()) { throw new CanceledException(); } } IndicatingOutputStream(File file, int size, ProgressIndicator indicator); void addObserver(OutputStream observer); void write(int i); void write(byte[] bytes); void write(byte[] bytes, int off, int len); }
@Test public void testCancel() throws IOException { IndicatingOutputStream ios = new IndicatingOutputStream(file, 20, new ProgressIndicatorBase() { @Override public void setFraction(final double fraction) { cancel(); } }); ios.write("1234\n".getBytes()); try { ios.write("123456789\n".getBytes()); Assert.fail("Should have failed"); } catch (CanceledException e) { } Assert.assertEquals("1234\n", FileUtils.readFileToString(file)); }
PathUtils { public static String pathJoin(String separator, String ... parts) { StringBuilder builder = new StringBuilder(); if (parts.length == 0) return ""; if (parts.length == 1) return parts[0]; for (int i = 0; i < parts.length; i++) { String part = parts[i]; if (i == 0) { builder.append(org.apache.commons.lang.StringUtils.removeEnd(part, separator)).append(separator); } else if (i == parts.length - 1) { builder.append(org.apache.commons.lang.StringUtils.removeStart(part, separator)); } else { builder.append(org.apache.commons.lang.StringUtils.removeStart(org.apache.commons.lang.StringUtils.removeEnd(part, separator), separator)).append(separator); } } return builder.toString(); } static String pathJoin(String separator, String ... parts); }
@Test public void testPathJoin() throws Exception { assertThat(pathJoin("/", "aaa", "bbb"), is("aaa/bbb")); assertThat(pathJoin("/", "a", "b"), is("a/b")); assertThat(pathJoin("/", "a/", "/b"), is("a/b")); assertThat(pathJoin("/", "a/", "b/"), is("a/b/")); assertThat(pathJoin("/"), is("")); assertThat(pathJoin("/", "a"), is("a")); assertThat(pathJoin("/", "/a/"), is("/a/")); }
HpAlmTask extends Task { public Comment[] getComments() { return parseComments(entity.getPropertyValue(entity.isInitialized("dev-comments")? "dev-comments": "comments")); } HpAlmTask(Project project, Entity entity); boolean isInitialized(); String getId(); String getSummary(); String getDescription(); Comment[] getComments(); Icon getIcon(); TaskType getType(); Date getUpdated(); Date getCreated(); boolean isClosed(); String getCustomIcon(); boolean isIssue(); String getIssueUrl(); static Date parseDate(String dateStr); static String getDescriptionField(String entityType); }
@Test public void testGetComments() { Entity entity = new Entity("defect", 1); String html = "<html><body>\n" + "<strong> Joe Joe, Fri Sep 07 2012:</strong><br>\nComment1\n" + "<strong>________________________________________</strong><br>\n" + "<strong> Jim Jim, Fri Sep 07 2012:</strong><br>\nComment2\n" + "<b>________________________________________</b><br>\n" + "<strong> John John, Fri Sep 07 2012:</strong><br>\nComment3\n" + "</body></html>"; entity.setProperty("dev-comments", html); HpAlmTask task = new HpAlmTask(getProject(), entity); Assert.assertEquals(3, task.getComments().length); Assert.assertEquals("Joe Joe", task.getComments()[0].getAuthor()); Assert.assertEquals("Jim Jim", task.getComments()[1].getAuthor()); Assert.assertEquals("John John", task.getComments()[2].getAuthor()); Entity requirement = new Entity("requirement", 1); requirement.setProperty("comments", html); task = new HpAlmTask(getProject(), requirement); Assert.assertEquals(3, task.getComments().length); }
HpAlmTask extends Task { public TaskType getType() { if("defect".equals(entity.getType())) { return TaskType.BUG; } else { return TaskType.FEATURE; } } HpAlmTask(Project project, Entity entity); boolean isInitialized(); String getId(); String getSummary(); String getDescription(); Comment[] getComments(); Icon getIcon(); TaskType getType(); Date getUpdated(); Date getCreated(); boolean isClosed(); String getCustomIcon(); boolean isIssue(); String getIssueUrl(); static Date parseDate(String dateStr); static String getDescriptionField(String entityType); }
@Test public void testGetType() { Entity defect = new Entity("defect", 1); HpAlmTask task = new HpAlmTask(getProject(), defect); Assert.assertEquals(TaskType.BUG, task.getType()); Entity requirement = new Entity("requirement", 1); HpAlmTask task2 = new HpAlmTask(getProject(), requirement); Assert.assertEquals(TaskType.FEATURE, task2.getType()); }
HpAlmTask extends Task { public Date getUpdated() { return parseDate(entity.getPropertyValue("last-modified")); } HpAlmTask(Project project, Entity entity); boolean isInitialized(); String getId(); String getSummary(); String getDescription(); Comment[] getComments(); Icon getIcon(); TaskType getType(); Date getUpdated(); Date getCreated(); boolean isClosed(); String getCustomIcon(); boolean isIssue(); String getIssueUrl(); static Date parseDate(String dateStr); static String getDescriptionField(String entityType); }
@Test public void testGetUpdated() { Entity defect = new Entity("defect", 1); defect.setProperty("last-modified", "2012-12-12 12:12:12"); HpAlmTask task = new HpAlmTask(getProject(), defect); Assert.assertEquals("2012-12-12 12:12:12 +0100", HpAlmCommentTest.format.format(task.getUpdated())); }
HpAlmTask extends Task { public Date getCreated() { try { Date date = CommentField.dateFormat.parse(entity.getPropertyValue("creation-time")); if("requirement".equals(entity.getType())) { return new Date(date.getTime() + timeFormat.parse(entity.getPropertyValue("req-time")).getTime() + TimeZone.getDefault().getRawOffset()); } return date; } catch(ParseException e) { return getUpdated(); } } HpAlmTask(Project project, Entity entity); boolean isInitialized(); String getId(); String getSummary(); String getDescription(); Comment[] getComments(); Icon getIcon(); TaskType getType(); Date getUpdated(); Date getCreated(); boolean isClosed(); String getCustomIcon(); boolean isIssue(); String getIssueUrl(); static Date parseDate(String dateStr); static String getDescriptionField(String entityType); }
@Test public void testGetCreated() { Entity defect = new Entity("defect", 1); defect.setProperty("creation-time", "2012-12-12"); HpAlmTask task = new HpAlmTask(getProject(), defect); Assert.assertEquals("2012-12-12 00:00:00 +0100", HpAlmCommentTest.format.format(task.getCreated())); } @Test public void testGetCreated_requirement() { Entity requirement = new Entity("requirement", 1); requirement.setProperty("creation-time", "2012-12-12"); requirement.setProperty("req-time", "12:12:12"); HpAlmTask task = new HpAlmTask(getProject(), requirement); Assert.assertEquals("2012-12-12 12:12:12 +0100", HpAlmCommentTest.format.format(task.getCreated())); }
HpAlmTask extends Task { public boolean isClosed() { if("defect".equals(entity.getType())) { return "Closed".equals(entity.getPropertyValue("status")); } else { return false; } } HpAlmTask(Project project, Entity entity); boolean isInitialized(); String getId(); String getSummary(); String getDescription(); Comment[] getComments(); Icon getIcon(); TaskType getType(); Date getUpdated(); Date getCreated(); boolean isClosed(); String getCustomIcon(); boolean isIssue(); String getIssueUrl(); static Date parseDate(String dateStr); static String getDescriptionField(String entityType); }
@Test public void testIsClosed() { Entity defect = new Entity("defect", 1); HpAlmTask task = new HpAlmTask(getProject(), defect); defect.setProperty("status", "Closed"); Assert.assertTrue(task.isClosed()); defect.setProperty("status", "Open"); Assert.assertFalse(task.isClosed()); Entity requirement = new Entity("requirement", 1); HpAlmTask task2 = new HpAlmTask(getProject(), requirement); Assert.assertFalse(task2.isClosed()); }
HpAlmTask extends Task { public boolean isIssue() { return getType() == TaskType.BUG; } HpAlmTask(Project project, Entity entity); boolean isInitialized(); String getId(); String getSummary(); String getDescription(); Comment[] getComments(); Icon getIcon(); TaskType getType(); Date getUpdated(); Date getCreated(); boolean isClosed(); String getCustomIcon(); boolean isIssue(); String getIssueUrl(); static Date parseDate(String dateStr); static String getDescriptionField(String entityType); }
@Test public void testIsIssue() { Entity defect = new Entity("defect", 1); HpAlmTask task = new HpAlmTask(getProject(), defect); Assert.assertTrue(task.isIssue()); Entity requirement = new Entity("requirement", 1); HpAlmTask task2 = new HpAlmTask(getProject(), requirement); Assert.assertFalse(task2.isIssue()); }
HpAlmTask extends Task { public String getIssueUrl() { if(openInBrowserAvailable) { return _getIssueUrl(); } else { return null; } } HpAlmTask(Project project, Entity entity); boolean isInitialized(); String getId(); String getSummary(); String getDescription(); Comment[] getComments(); Icon getIcon(); TaskType getType(); Date getUpdated(); Date getCreated(); boolean isClosed(); String getCustomIcon(); boolean isIssue(); String getIssueUrl(); static Date parseDate(String dateStr); static String getDescriptionField(String entityType); }
@Test public void testGetIssueUrl() { Entity defect = new Entity("defect", 1); HpAlmTask task = new HpAlmTask(getProject(), defect); String url = task._getIssueUrl(); Assert.assertEquals("td: Entity requirement = new Entity("requirement", 2); HpAlmTask task2 = new HpAlmTask(getProject(), requirement ); String url2 = task2._getIssueUrl(); Assert.assertEquals("td: }
HpAlmTask extends Task { public static Date parseDate(String dateStr) { try { return dateTimeFormat.parse(dateStr); } catch (ParseException e) { return new Date(); } } HpAlmTask(Project project, Entity entity); boolean isInitialized(); String getId(); String getSummary(); String getDescription(); Comment[] getComments(); Icon getIcon(); TaskType getType(); Date getUpdated(); Date getCreated(); boolean isClosed(); String getCustomIcon(); boolean isIssue(); String getIssueUrl(); static Date parseDate(String dateStr); static String getDescriptionField(String entityType); }
@Test public void testParseDate() { Date date = HpAlmTask.parseDate("2012-12-12 12:12:12"); Assert.assertEquals("2012-12-12 12:12:12 +0100", HpAlmCommentTest.format.format(date)); }
HpAlmTask extends Task { public static String getDescriptionField(String entityType) { if("defect".equals(entityType)) { return "description"; } else { return "req-comment"; } } HpAlmTask(Project project, Entity entity); boolean isInitialized(); String getId(); String getSummary(); String getDescription(); Comment[] getComments(); Icon getIcon(); TaskType getType(); Date getUpdated(); Date getCreated(); boolean isClosed(); String getCustomIcon(); boolean isIssue(); String getIssueUrl(); static Date parseDate(String dateStr); static String getDescriptionField(String entityType); }
@Test public void testGetDescriptionField() { Assert.assertEquals("description", HpAlmTask.getDescriptionField("defect")); Assert.assertEquals("req-comment", HpAlmTask.getDescriptionField("requirement")); }
EntityLabelService extends AbstractCachingService<Integer, Map<String, String>, AbstractCachingService.Callback<Map<String, String>>> { public void loadEntityLabelAsync(final String entityType, Callback<String> callback) { getValueAsync(ENTITIES, translate(callback, new Transform<Map<String, String>, String>() { @Override public String transform(Map<String, String> labelMap) { if(labelMap.containsKey(entityType)) { return labelMap.get(entityType); } else { return entityType; } } })); } EntityLabelService(Project project, RestService restService); void loadEntityLabelAsync(final String entityType, Callback<String> callback); }
@Test public void testLoadEntityLabelAsync() { handler.async(2); entityLabelService.loadEntityLabelAsync("defect", new NonDispatchTestCallback<String>(handler) { @Override protected void evaluate(String data) { Assert.assertEquals("Defect", data); } }); entityLabelService.loadEntityLabelAsync("defect", new DispatchTestCallback<String>(handler) { @Override protected void evaluate(String data) { Assert.assertEquals("Defect", data); } }); }
TaskManagerIntegration { public void activate(Entity entity) { if(entity == null) { activateDefaultTask(); } else { HpAlmTask task = new HpAlmTask(project, entity); if(!task.isInitialized()) { entityService.getEntityAsync(new EntityRef(entity), new EntityAdapter() { @Override public void entityLoaded(final Entity entity, Event event) { ApplicationUtil.invokeLaterIfNeeded(new Runnable() { public void run() { activateTask(new HpAlmTask(project, entity)); } }); } }); } else { activateTask(task); } } } TaskManagerIntegration(Project project, EntityService entityService); void activate(Entity entity); void addListener(Listener listener); void removeListener(Listener listener); }
@Test public void testActivate() { Entity defect = new Entity("defect", 1); defect.setProperty("name", "Name..."); defect.setProperty("description", "Description..."); defect.setProperty("dev-comments", "Comments..."); defect.setProperty("last-modified", "2012-12-12 12:12:12"); defect.setProperty("creation-time", "2012-12-12"); taskManagerIntegration.activate(defect); Assert.assertEquals("defect #1: Name...", taskManager.getActiveTask().getPresentableName()); } @Test public void testActivate_uninitialized() { RestInvocations.loadMetadata(handler, "defect"); RestInvocations.loadMetadata(handler, "release-backlog-item"); handler.addRequest("GET", "/qcbin/rest/domains/domain/projects/project/defects?fields=actual-fix-time,attachment,in-bucket,changeset,build-closed,closing-version,closing-date,dev-comments,id,status,description,detected-by,build-detected,detected-in-rcyc,detected-in-rel,detection-version,creation-time,estimated-fix-time,extended-reference,fixed-on-date,has-change,has-linkage,has-others-linkage,last-modified,planned-closing-ver,priority,user-04,user-03,reproducible,severity,subject,name,user-02,user-01,watch-id,release-backlog-item.product-id,release-backlog-item.owner,release-backlog-item.blocked,release-backlog-item.entity-name,release-backlog-item.entity-type,release-backlog-item.feature-id,release-backlog-item.invested,release-backlog-item.kanban-status-id,release-backlog-item.linked-entities-info,release-backlog-item.no-of-sons,release-backlog-item.kanban-parent-status-id,release-backlog-item.rank,release-backlog-item.release-id,release-backlog-item.entity-id,release-backlog-item.remaining,release-backlog-item.sprint-id,release-backlog-item.status,release-backlog-item.kan-parent-duration,release-backlog-item.story-points,release-backlog-item.kan-status-duration,release-backlog-item.team-id,release-backlog-item.theme-id,release-backlog-item.estimated,release-backlog-item.watch-id,release-backlog-item.id,product-group-id&query={id[86]}&order-by={}", 200) .content("entityServiceTest_entity.xml"); Entity defect = new Entity("defect", 86); handler.async(); taskManager.addTaskListener(new TaskListenerAdapter() { @Override public void taskActivated(final LocalTask localTask) { taskManager.removeTaskListener(this); handler.done(new Runnable() { @Override public void run() { Assert.assertEquals("defect #86: somewhat", localTask.getPresentableName()); } }); } }); taskManagerIntegration.activate(defect); } @Test public void testActivate_default() { handler.async(); ApplicationUtil.invokeLaterIfNeeded(new Runnable() { @Override public void run() { testActivate(); taskManagerIntegration.activate(null); Assert.assertEquals("Default task", taskManager.getActiveTask().getPresentableName()); handler.done(); } }); }
HpAlmRepository extends TaskRepository implements Comparable<HpAlmRepository> { public Task[] getIssues(String query, int max, long since) throws Exception { if(!_assignProject()) { return new Task[0]; } List<HpAlmTask> list = new LinkedList<HpAlmTask>(); loadTasks(query, defect, "defect", list); loadTasks(query, requirement, "requirement", list); return list.toArray(new Task[list.size()]); } HpAlmRepository(); HpAlmRepository(String url, long id); void setId(long id); @Tag("defect") TaskConfig getDefect(); void setDefect(TaskConfig defect); @Tag("requirement") TaskConfig getRequirement(); void setRequirement(TaskConfig requirement); @Attribute("id") long getId(); String getPresentableName(); boolean isConfigured(); Task[] getIssues(String query, int max, long since); @Override void setPreferredOpenTaskState(@Nullable CustomTaskState customTaskState); @Nullable @Override CustomTaskState getPreferredOpenTaskState(); @Override void setPreferredCloseTaskState(@Nullable CustomTaskState customTaskState); @Nullable @Override CustomTaskState getPreferredCloseTaskState(); Task findTask(String taskName); String extractId(String taskName); HpAlmRepository clone(); boolean equals(Object o); int hashCode(); int compareTo(HpAlmRepository other); }
@Test public void testGetIssues() throws Exception { RestInvocations.loadMetadata(handler, "defect"); RestInvocations.loadMetadata(handler, "release-backlog-item"); RestInvocations.loadMetadata(handler, "requirement"); handler.addRequest(false, "GET", "/qcbin/rest/domains/domain/projects/project/defects?fields=&query={name['*what*']}&order-by={}", 200) .content("entityServiceTest_entity.xml"); handler.addRequest(false, "GET", "/qcbin/rest/domains/domain/projects/project/requirements?fields=&query={name['*what*']}&order-by={}", 200) .content("no_entities.xml"); HpAlmRepository repository = new HpAlmRepository(getProject().getName(), 1); repository._assignProject(); Task[] list = repository.getIssues("what", 5, 100); Assert.assertEquals(1, list.length); checkTask(list[0]); } @Test public void testGetIssues_unassigned() throws Exception { HpAlmRepository repository = new HpAlmRepository(); Task[] list = repository.getIssues("foo", 5, 100); Assert.assertEquals(0, list.length); }
HpAlmRepository extends TaskRepository implements Comparable<HpAlmRepository> { public Task findTask(String taskName) throws Exception { if(!_assignProject()) { return null; } Entity entity = project.getComponent(EntityService.class).getEntity(new EntityRef(taskName)); return new HpAlmTask(project, entity); } HpAlmRepository(); HpAlmRepository(String url, long id); void setId(long id); @Tag("defect") TaskConfig getDefect(); void setDefect(TaskConfig defect); @Tag("requirement") TaskConfig getRequirement(); void setRequirement(TaskConfig requirement); @Attribute("id") long getId(); String getPresentableName(); boolean isConfigured(); Task[] getIssues(String query, int max, long since); @Override void setPreferredOpenTaskState(@Nullable CustomTaskState customTaskState); @Nullable @Override CustomTaskState getPreferredOpenTaskState(); @Override void setPreferredCloseTaskState(@Nullable CustomTaskState customTaskState); @Nullable @Override CustomTaskState getPreferredCloseTaskState(); Task findTask(String taskName); String extractId(String taskName); HpAlmRepository clone(); boolean equals(Object o); int hashCode(); int compareTo(HpAlmRepository other); }
@Test public void testFindTask() throws Exception { RestInvocations.loadMetadata(handler, "defect"); RestInvocations.loadMetadata(handler, "release-backlog-item"); handler.addRequest("GET", "/qcbin/rest/domains/domain/projects/project/defects?fields=actual-fix-time,attachment,in-bucket,changeset,build-closed,closing-version,closing-date,dev-comments,id,status,description,detected-by,build-detected,detected-in-rcyc,detected-in-rel,detection-version,creation-time,estimated-fix-time,extended-reference,fixed-on-date,has-change,has-linkage,has-others-linkage,last-modified,planned-closing-ver,priority,user-04,user-03,reproducible,severity,subject,name,user-02,user-01,watch-id,release-backlog-item.product-id,release-backlog-item.owner,release-backlog-item.blocked,release-backlog-item.entity-name,release-backlog-item.entity-type,release-backlog-item.feature-id,release-backlog-item.invested,release-backlog-item.kanban-status-id,release-backlog-item.linked-entities-info,release-backlog-item.no-of-sons,release-backlog-item.kanban-parent-status-id,release-backlog-item.rank,release-backlog-item.release-id,release-backlog-item.entity-id,release-backlog-item.remaining,release-backlog-item.sprint-id,release-backlog-item.status,release-backlog-item.kan-parent-duration,release-backlog-item.story-points,release-backlog-item.kan-status-duration,release-backlog-item.team-id,release-backlog-item.theme-id,release-backlog-item.estimated,release-backlog-item.watch-id,release-backlog-item.id,product-group-id&query={id[86]}&order-by={}", 200) .content("entityServiceTest_entity.xml"); HpAlmRepository repository = new HpAlmRepository(getProject().getName(), 1); repository._assignProject(); Task task = repository.findTask("defect #86"); checkTask(task); } @Test public void testFindTask_unassigned() throws Exception { HpAlmRepository repository = new HpAlmRepository(); Task task = repository.findTask("defect #86"); Assert.assertNull(task); }
HpAlmRepository extends TaskRepository implements Comparable<HpAlmRepository> { public String extractId(String taskName) { return taskName; } HpAlmRepository(); HpAlmRepository(String url, long id); void setId(long id); @Tag("defect") TaskConfig getDefect(); void setDefect(TaskConfig defect); @Tag("requirement") TaskConfig getRequirement(); void setRequirement(TaskConfig requirement); @Attribute("id") long getId(); String getPresentableName(); boolean isConfigured(); Task[] getIssues(String query, int max, long since); @Override void setPreferredOpenTaskState(@Nullable CustomTaskState customTaskState); @Nullable @Override CustomTaskState getPreferredOpenTaskState(); @Override void setPreferredCloseTaskState(@Nullable CustomTaskState customTaskState); @Nullable @Override CustomTaskState getPreferredCloseTaskState(); Task findTask(String taskName); String extractId(String taskName); HpAlmRepository clone(); boolean equals(Object o); int hashCode(); int compareTo(HpAlmRepository other); }
@Test public void testExtractId() { HpAlmRepository repository = new HpAlmRepository(); Assert.assertEquals("defect #123", repository.extractId("defect #123")); }
HpAlmRepository extends TaskRepository implements Comparable<HpAlmRepository> { public HpAlmRepository clone() { HpAlmRepository ret = new HpAlmRepository(getUrl(), id); ret.requirement = requirement; ret.defect = defect; return ret; } HpAlmRepository(); HpAlmRepository(String url, long id); void setId(long id); @Tag("defect") TaskConfig getDefect(); void setDefect(TaskConfig defect); @Tag("requirement") TaskConfig getRequirement(); void setRequirement(TaskConfig requirement); @Attribute("id") long getId(); String getPresentableName(); boolean isConfigured(); Task[] getIssues(String query, int max, long since); @Override void setPreferredOpenTaskState(@Nullable CustomTaskState customTaskState); @Nullable @Override CustomTaskState getPreferredOpenTaskState(); @Override void setPreferredCloseTaskState(@Nullable CustomTaskState customTaskState); @Nullable @Override CustomTaskState getPreferredCloseTaskState(); Task findTask(String taskName); String extractId(String taskName); HpAlmRepository clone(); boolean equals(Object o); int hashCode(); int compareTo(HpAlmRepository other); }
@Test public void testClone() { HpAlmRepository repository = new HpAlmRepository(getProject().getName(), 1); HpAlmRepository clone = repository.clone(); Assert.assertEquals(repository.getId(), clone.getId()); Assert.assertEquals(repository.getUrl(), clone.getUrl()); Assert.assertEquals(repository.getDefect(), clone.getDefect()); Assert.assertEquals(repository.getRequirement(), clone.getRequirement()); }
HpAlmRepository extends TaskRepository implements Comparable<HpAlmRepository> { public int compareTo(HpAlmRepository other) { if(id < other.id) { return -1; } else if(id > other.id) { return 1; } else { return 0; } } HpAlmRepository(); HpAlmRepository(String url, long id); void setId(long id); @Tag("defect") TaskConfig getDefect(); void setDefect(TaskConfig defect); @Tag("requirement") TaskConfig getRequirement(); void setRequirement(TaskConfig requirement); @Attribute("id") long getId(); String getPresentableName(); boolean isConfigured(); Task[] getIssues(String query, int max, long since); @Override void setPreferredOpenTaskState(@Nullable CustomTaskState customTaskState); @Nullable @Override CustomTaskState getPreferredOpenTaskState(); @Override void setPreferredCloseTaskState(@Nullable CustomTaskState customTaskState); @Nullable @Override CustomTaskState getPreferredCloseTaskState(); Task findTask(String taskName); String extractId(String taskName); HpAlmRepository clone(); boolean equals(Object o); int hashCode(); int compareTo(HpAlmRepository other); }
@Test public void testCompareTo() { HpAlmRepository repository1 = new HpAlmRepository(getProject().getName(), 1); HpAlmRepository repository2 = new HpAlmRepository(getProject().getName(), 2); Assert.assertEquals(-1, repository1.compareTo(repository2)); Assert.assertEquals(1, repository2.compareTo(repository1)); Assert.assertEquals(0, repository1.compareTo(repository1)); }
ProjectUserService extends AbstractCachingService<Integer, UserList, AbstractCachingService.Callback<UserList>> { public User getUser(String username) { for(User user: getUserList()) { if(user.getUsername().equals(username)) { return user; } } return null; } ProjectUserService(Project project); void loadUsersAsync(Callback<UserList> callback); User tryGetUser(String username); void loadUserAsync(final String username, final Callback<User> callback); UserList getUserList(); User getUser(String username); String getUserFullName(String username); }
@Test public void testGetUser() { RestInvocations.loadProjectUsers(handler); User tester = projectUserService.getUser("tester"); Assert.assertEquals("tester", tester.getUsername()); Assert.assertEquals("Integration Test", tester.getFullName()); projectUserService.getUser("tester"); } @Test public void testGetUser_nonExisting() { RestInvocations.loadProjectUsers(handler); Assert.assertNull(projectUserService.getUser("nonExisting")); }
SubversionRevisionFactory implements RevisionFactory { @Override public boolean matches(VcsRoot vcsRoot, String location, String alias) { SvnVcs svnVcs = (SvnVcs) vcsRoot.getVcs(); String url = svnVcs.getInfo(vcsRoot.getPath()).getRepositoryRootURL().toString(); return url.equals(location) || url.equals(alias); } @Override VcsRevisionNumber create(String revision); @Override boolean matches(VcsRoot vcsRoot, String location, String alias); @Override String getType(); }
@Test public void testMatches() throws SVNException { Info info = Mockito.mock(Info.class); Mockito.when(info.getRepositoryRootURL()).thenReturn(SVNURL.parseURIDecoded("http: SvnVcs spy = Mockito.spy(svnVcs); LightVirtualFile file = new LightVirtualFile(); Mockito.doReturn(info).when(spy).getInfo(file); Assert.assertFalse(subversionRevisionFactory.matches(new VcsRoot(spy, file), "location", "alias")); Assert.assertTrue(subversionRevisionFactory.matches(new VcsRoot(spy, file), "http: Assert.assertTrue(subversionRevisionFactory.matches(new VcsRoot(spy, file), "location", "http: }
SubversionRevisionFactory implements RevisionFactory { @Override public VcsRevisionNumber create(String revision) { try { return new SvnRevisionNumber(SVNRevision.create(Long.valueOf(revision))); } catch (NumberFormatException e) { return null; } } @Override VcsRevisionNumber create(String revision); @Override boolean matches(VcsRoot vcsRoot, String location, String alias); @Override String getType(); }
@Test public void testCreate() { VcsRevisionNumber revisionNumber = subversionRevisionFactory.create("1234"); Assert.assertTrue(revisionNumber instanceof SvnRevisionNumber); Assert.assertEquals(1234, ((SvnRevisionNumber) revisionNumber).getLongRevisionNumber()); }
GitRevisionFactory implements RevisionFactory { @Override public boolean matches(VcsRoot vcsRoot, String location, String alias) { return false; } @Override GitRevisionNumber create(String revision); @Override boolean matches(VcsRoot vcsRoot, String location, String alias); @Override String getType(); }
@Test public void testMatches() { Assert.assertFalse(gitRevisionFactory.matches(new VcsRoot(gitVcs, new LightVirtualFile()), "location", "alias")); }
GitRevisionFactory implements RevisionFactory { @Override public GitRevisionNumber create(String revision) { return new GitRevisionNumber(revision.replaceFirst(" .*$", "")); } @Override GitRevisionNumber create(String revision); @Override boolean matches(VcsRoot vcsRoot, String location, String alias); @Override String getType(); }
@Test public void testCreate() { VcsRevisionNumber revisionNumber = gitRevisionFactory.create("2a7314b614b70b1d007236cbe2bf0b0d3028693d master"); Assert.assertTrue(revisionNumber instanceof GitRevisionNumber); Assert.assertEquals("2a7314b614b70b1d007236cbe2bf0b0d3028693d", ((GitRevisionNumber) revisionNumber).getRev()); }
SpellCheckTokenizer { public SpellCheckTokenizer(String text) { this.text = text; wordIterator = BreakIterator.getWordInstance(); wordIterator.setText(text); wordIterator.first(); } SpellCheckTokenizer(String text); boolean hasMoreTokens(); Token nextToken(); }
@Test public void testSpellCheckTokenizer() { check("Gives words except 12345 or punctuation, and like.\n", new SpellCheckTokenizer.Token("Gives", 0), new SpellCheckTokenizer.Token("words", 6), new SpellCheckTokenizer.Token("except", 12), new SpellCheckTokenizer.Token("or", 25), new SpellCheckTokenizer.Token("punctuation", 28), new SpellCheckTokenizer.Token("and", 41), new SpellCheckTokenizer.Token("like", 45)); }
NavigationListener implements HyperlinkListener { public void hyperlinkUpdate(HyperlinkEvent hyperlinkEvent) { if(hyperlinkEvent.getEventType() == HyperlinkEvent.EventType.ACTIVATED) { for(Recognizer recognizer: NavigationDecorator.recognizers) { if(recognizer.navigate(project, hyperlinkEvent.getDescription())) { break; } } } } NavigationListener(Project project); void hyperlinkUpdate(HyperlinkEvent hyperlinkEvent); }
@Test public void testNavigate() { handler.async(); getComponent(BrowserUtil.class)._setLauncher(new BrowserUtil.Launcher() { @Override public void launchBrowser(final String url) { handler.done(new Runnable() { @Override public void run() { Assert.assertEquals("http: } }); } }); new NavigationListener(getProject()).hyperlinkUpdate(new HyperlinkEvent(this, HyperlinkEvent.EventType.ACTIVATED, null, "web:http: }
NavigationDecorator { public static String explode(Project project, String plain) { return explode(project, plain, false); } static String explode(Project project, String plain); static String explodeHtml(Project project, String html); static List<Recognizer> recognizers; }
@Test public void testExplode() throws InterruptedException { String value = NavigationDecorator.explode(getProject(), "Go to http: Assert.assertEquals( "Go to <a href=\"web:http: }
NavigationDecorator { public static String explodeHtml(Project project, String html) { return explode(project, html, true); } static String explode(Project project, String plain); static String explodeHtml(Project project, String html); static List<Recognizer> recognizers; }
@Test public void testExplodeHtml() throws InterruptedException { String value = NavigationDecorator.explodeHtml(getProject(), "Go to http: Assert.assertEquals( "Go to <a href=\"web:http: } @Test public void testExplodeHtmlKeepAHref() throws InterruptedException { String value = NavigationDecorator.explodeHtml(getProject(), "Go to http: Assert.assertEquals( "Go to <a href=\"web:http: }
JavaStackTraceRecognizer extends ClassRecognizer { @Override public void recognize(String content, List<Candidate> candidates) { Matcher matcher = STACKTRACE_PATTERN.matcher(content); while(matcher.find()) { String className; String signature = matcher.group(2); if(signature.contains(".access$")) { signature = signature.replaceFirst("\\.access\\$\\d+", ".access"); } if(signature.contains("$")) { className = signature.substring(0, signature.indexOf("$")); } else { className = signature.substring(0, signature.lastIndexOf(".")); } String line = matcher.group(6); candidates.add(new ClassCandidate(matcher.start(), matcher.end(), matcher.start(3), matcher.end(3), className, matcher.group(4), line == null? 0: Integer.valueOf(line), null)); } } @Override void recognize(String content, List<Candidate> candidates); }
@Test public void testSimpleCase() { LinkedList<Candidate> list = new LinkedList<Candidate>(); String value = "prefix at org.junit.runners.ParentRunner.run(ParentRunner.java:236) suffix"; recognizer.recognize(value, list); Assert.assertEquals(1, list.size()); checkClassCandidate(list.get(0), "org.junit.runners.ParentRunner", "ParentRunner", 236, null, value.indexOf("at org"), value.indexOf(" suffix"), value.indexOf("(") + 1, value.indexOf(")")); } @Test public void testGeneratedMethod() { LinkedList<Candidate> list = new LinkedList<Candidate>(); String value = "prefix at org.junit.runners.ParentRunner.access$000(ParentRunner.java:42) suffix"; recognizer.recognize(value, list); Assert.assertEquals(1, list.size()); checkClassCandidate(list.get(0), "org.junit.runners.ParentRunner", "ParentRunner", 42, null, value.indexOf("at org"), value.indexOf(" suffix"), value.indexOf("(") + 1, value.indexOf(")")); } @Test public void testAnonymousClass() { LinkedList<Candidate> list = new LinkedList<Candidate>(); String value = "prefix at org.junit.runners.ParentRunner$2.evaluate(ParentRunner.java:184) suffix"; recognizer.recognize(value, list); Assert.assertEquals(1, list.size()); checkClassCandidate(list.get(0), "org.junit.runners.ParentRunner", "ParentRunner", 184, null, value.indexOf("at org"), value.indexOf(" suffix"), value.indexOf("(") + 1, value.indexOf(")")); } @Test public void testMultiple() { LinkedList<Candidate> list = new LinkedList<Candidate>(); String value = "prefix at org.junit.runners.ParentRunner.run2(ParentRunner.java:230) suffix\n" + "prefix at org.junit.runners.ParentRunner.run1(ParentRunner.java:236) suffix"; int firstLineLength = value.indexOf("prefix", 1); recognizer.recognize(value, list); Assert.assertEquals(2, list.size()); checkClassCandidate(list.get(0), "org.junit.runners.ParentRunner", "ParentRunner", 230, null, value.indexOf("at org"), value.indexOf(" suffix"), value.indexOf("(") + 1, value.indexOf(")")); checkClassCandidate(list.get(1), "org.junit.runners.ParentRunner", "ParentRunner", 236, null, value.indexOf("at org") + firstLineLength, value.indexOf(" suffix") + firstLineLength, value.indexOf("(") + 1 + firstLineLength, value.indexOf(")") + firstLineLength); }
WebLinkRecognizer implements Recognizer { @Override public void recognize(String content, List<Candidate> candidates) { Matcher matcher = WEB_PATTERN.matcher(content); while(matcher.find()) { candidates.add(new Candidate(matcher.start(), matcher.end(), "web:" + matcher.group())); } } @Override void recognize(String content, List<Candidate> candidates); @Override boolean navigate(Project project, String hyperlink); }
@Test public void testRecognize() { LinkedList<Candidate> list = new LinkedList<Candidate>(); String value = "prefix http: recognizer.recognize(value, list); Assert.assertEquals(1, list.size()); AbstractRecognizerTest.checkCandidate(list.get(0), "web:http: } @Test public void testMultiple() { LinkedList<Candidate> list = new LinkedList<Candidate>(); String value = "prefix http: recognizer.recognize(value, list); Assert.assertEquals(2, list.size()); AbstractRecognizerTest.checkCandidate(list.get(0), "web:http: AbstractRecognizerTest.checkCandidate(list.get(1), "web:https: }
WebLinkRecognizer implements Recognizer { @Override public boolean navigate(Project project, String hyperlink) { if(hyperlink.startsWith("web:")) { project.getComponent(BrowserUtil.class).launchBrowser(EntityQuery.decode(hyperlink.substring(4))); return true; } else { return false; } } @Override void recognize(String content, List<Candidate> candidates); @Override boolean navigate(Project project, String hyperlink); }
@Test public void testNavigate() { handler.async(); getComponent(BrowserUtil.class)._setLauncher(new BrowserUtil.Launcher() { @Override public void launchBrowser(final String url) { handler.done(new Runnable() { @Override public void run() { Assert.assertEquals("http: } }); } }); Assert.assertTrue(recognizer.navigate(getProject(), "web:http: } @Test public void testNavigate_negative() { Assert.assertFalse(recognizer.navigate(getProject(), "")); }
JavaCompileRecognizer extends ClassRecognizer { @Override public void recognize(String content, List<Candidate> candidates) { Matcher matcher = COMPILE_PATTERN.matcher(content); while(matcher.find()) { candidates.add(new ClassCandidate(matcher.start(), matcher.end(), matcher.start(2), matcher.end(2), matcher.group(3), matcher.group(3), Integer.valueOf(matcher.group(4)), null)); } } @Override void recognize(String content, List<Candidate> candidates); }
@Test public void testRecognize() { LinkedList<Candidate> list = new LinkedList<Candidate>(); String value = "prefix /usr/src/test/java/hello/HelloWorldTest.java:[19,27] suffix"; recognizer.recognize(value, list); Assert.assertEquals(1, list.size()); checkClassCandidate(list.get(0), "HelloWorldTest", "HelloWorldTest", 19, null, value.indexOf("/"), value.indexOf(" suffix"), value.indexOf("HelloWorldTest"), value.indexOf(":")); } @Test public void testMultiple() { LinkedList<Candidate> list = new LinkedList<Candidate>(); String value = "prefix /usr/src/test/java/hello/HelloWorldTest.java:[19,27] middle\n" + "/var/src/other/OtherWorldTest.java:[11,27] suffix"; recognizer.recognize(value, list); Assert.assertEquals(2, list.size()); checkClassCandidate(list.get(0), "HelloWorldTest", "HelloWorldTest", 19, null, value.indexOf("/usr"), value.indexOf(" middle"), value.indexOf("HelloWorldTest"), value.indexOf(":[19,27]")); checkClassCandidate(list.get(1), "OtherWorldTest", "OtherWorldTest", 11, null, value.indexOf("/var"), value.indexOf(" suffix"), value.indexOf("OtherWorldTest"), value.indexOf(":[11,27]")); }
ClassRecognizer implements Recognizer { public boolean navigate(Project project, String hyperlink) { if(hyperlink.startsWith("goto:")) { openEditor(project, hyperlink.substring(5)); return true; } else { return false; } } boolean navigate(Project project, String hyperlink); }
@Test public void testNavigate_class() { handler.async(2); getComponent(EditSourceUtil.class)._setNavigator(new EditSourceUtil.Navigator() { @Override public void navigate(final NavigationItem item, final boolean requestFocus, final boolean useCurrentWindow) { handler.done(new Runnable() { @Override public void run() { Assert.assertEquals("PsiClass:Clazz", item.toString()); Assert.assertTrue(requestFocus); Assert.assertTrue(useCurrentWindow); } }); } }); final TextComponentEditor editor = new TextComponentEditor(getProject(), new JTextArea("1\n2\n3\n4\n5\n")); editor.getSelectionModel().setSelection(1, 2); final int line = 3; getComponent(FileEditorManager.class)._setSelector(new FileEditorManager.Selector() { @Override public Editor getSelectedTextEditor() { handler.done(); return editor; } }); createTestClazz(); boolean result = new ReadAction<Boolean>() { @Override protected void run(Result<Boolean> result) throws Throwable { String hyperlink = new ClassCandidate(1, 100, 10, 90, "test.Clazz", "Clazz", line, null).createLink(getProject()); result.setResult(new MyRecognizer().navigate(getProject(), hyperlink)); } }.execute().getResultObject(); Assert.assertTrue(result); Assert.assertEquals(new LogicalPosition(line - 1, 0), editor.getCaretModel().getLogicalPosition()); Assert.assertNull(editor.getSelectionModel().getSelectedText()); } @Test public void testNavigate_method() { handler.async(); getComponent(EditSourceUtil.class)._setNavigator(new EditSourceUtil.Navigator() { @Override public void navigate(final NavigationItem item, final boolean requestFocus, final boolean useCurrentWindow) { handler.done(new Runnable() { @Override public void run() { Assert.assertEquals("PsiMethod:one", item.toString()); Assert.assertTrue(requestFocus); Assert.assertTrue(useCurrentWindow); } }); } }); createTestClazz(); boolean result = new ReadAction<Boolean>() { @Override protected void run(Result<Boolean> result) throws Throwable { String hyperlink = new ClassCandidate(1, 100, 10, 90, "test.Clazz", "Clazz", 0, "one").createLink(getProject()); result.setResult(new MyRecognizer().navigate(getProject(), hyperlink)); } }.execute().getResultObject(); Assert.assertTrue(result); } @Test public void testNavigate_classNonQualified() { handler.async(2); getComponent(EditSourceUtil.class)._setNavigator(new EditSourceUtil.Navigator() { @Override public void navigate(final NavigationItem item, final boolean requestFocus, final boolean useCurrentWindow) { handler.done(new Runnable() { @Override public void run() { Assert.assertEquals("PsiClass:Clazz", item.toString()); Assert.assertTrue(requestFocus); Assert.assertTrue(useCurrentWindow); } }); } }); final TextComponentEditor editor = new TextComponentEditor(getProject(), new JTextArea("1\n2\n3\n4\n5\n")); editor.getSelectionModel().setSelection(1, 2); final int line = 3; getComponent(FileEditorManager.class)._setSelector(new FileEditorManager.Selector() { @Override public Editor getSelectedTextEditor() { handler.done(); return editor; } }); createTestClazz(); boolean result = new ReadAction<Boolean>() { @Override protected void run(Result<Boolean> result) throws Throwable { String hyperlink = new ClassCandidate(1, 100, 10, 90, "hello.Clazz", "Clazz", line, null).createLink(getProject()); result.setResult(new MyRecognizer().navigate(getProject(), hyperlink)); } }.execute().getResultObject(); Assert.assertTrue(result); Assert.assertEquals(new LogicalPosition(line - 1, 0), editor.getCaretModel().getLogicalPosition()); Assert.assertNull(editor.getSelectionModel().getSelectedText()); } @Test public void testNavigate_negative() { getComponent(EditSourceUtil.class)._setNavigator(new EditSourceUtil.Navigator() { @Override public void navigate(NavigationItem item, boolean requestFocus, boolean useCurrentWindow) { handler.fail("Not expected"); } }); createTestClazz(); boolean result = new ReadAction<Boolean>() { @Override protected void run(Result<Boolean> result) throws Throwable { result.setResult(new MyRecognizer().navigate(getProject(), "goto:c=test.Clazz2&f=Clazz2&l=3")); } }.execute().getResultObject(); Assert.assertTrue(result); }
ProjectUserService extends AbstractCachingService<Integer, UserList, AbstractCachingService.Callback<UserList>> { public User tryGetUser(String username) { UserList users = getCachedValue(1); if(users != null) { User user = users.getUser(username); if(user == null) { return new User(username, username); } return user; } else { return null; } } ProjectUserService(Project project); void loadUsersAsync(Callback<UserList> callback); User tryGetUser(String username); void loadUserAsync(final String username, final Callback<User> callback); UserList getUserList(); User getUser(String username); String getUserFullName(String username); }
@Test public void testTryGetUser() { User tester = projectUserService.tryGetUser("tester"); Assert.assertNull(tester); RestInvocations.loadProjectUsers(handler); projectUserService.getUser("tester"); tester = projectUserService.tryGetUser("tester"); Assert.assertEquals("tester", tester.getUsername()); Assert.assertEquals("Integration Test", tester.getFullName()); }
HREFLinkRecognizer implements Recognizer { @Override public void recognize(String content, final List<Candidate> candidates) { try { new ParserDelegator().parse(new StringReader(content), new ParserCallback(candidates), true); } catch (IOException e) { } } @Override void recognize(String content, final List<Candidate> candidates); @Override boolean navigate(Project project, String hyperlink); }
@Test public void testRecognize() { LinkedList<Candidate> list = new LinkedList<Candidate>(); String value = "<p>According to:&nbsp;<a>Development</a>&nbsp; (<a href=\"https: recognizer.recognize(value, list); Assert.assertEquals(1, list.size()); AbstractRecognizerTest.checkCandidate(list.get(0), null, value.indexOf("<a href"), value.indexOf(")</p>"), value.indexOf("<a href"), value.indexOf(")</p>")); }
HREFLinkRecognizer implements Recognizer { @Override public boolean navigate(Project project, String hyperlink) { if(hyperlink.matches("https?: project.getComponent(BrowserUtil.class).launchBrowser(hyperlink); return true; } else { return false; } } @Override void recognize(String content, final List<Candidate> candidates); @Override boolean navigate(Project project, String hyperlink); }
@Test public void testNavigate() { handler.async(); getComponent(BrowserUtil.class)._setLauncher(new BrowserUtil.Launcher() { @Override public void launchBrowser(final String url) { handler.done(new Runnable() { @Override public void run() { Assert.assertEquals("http: } }); } }); Assert.assertTrue(recognizer.navigate(getProject(), "http: } @Test public void testNavigate_negative() { Assert.assertFalse(recognizer.navigate(getProject(), "ftp: }
ProjectUserService extends AbstractCachingService<Integer, UserList, AbstractCachingService.Callback<UserList>> { public UserList getUserList() { return getValue(1); } ProjectUserService(Project project); void loadUsersAsync(Callback<UserList> callback); User tryGetUser(String username); void loadUserAsync(final String username, final Callback<User> callback); UserList getUserList(); User getUser(String username); String getUserFullName(String username); }
@Test public void testGetUserList() { RestInvocations.loadProjectUsers(handler); UserList userList = projectUserService.getUserList(); Assert.assertEquals(1, userList.size()); User tester = userList.getUser("tester"); Assert.assertEquals("tester", tester.getUsername()); Assert.assertEquals("Integration Test", tester.getFullName()); projectUserService.getUserList(); }
ProjectUserService extends AbstractCachingService<Integer, UserList, AbstractCachingService.Callback<UserList>> { public void loadUserAsync(final String username, final Callback<User> callback) { loadUsersAsync(translate(callback, new Transform<UserList, User>() { @Override public User transform(UserList users) { User user = users.getUser(username); if(user == null) { return new User(username, username); } else { return user; } } })); } ProjectUserService(Project project); void loadUsersAsync(Callback<UserList> callback); User tryGetUser(String username); void loadUserAsync(final String username, final Callback<User> callback); UserList getUserList(); User getUser(String username); String getUserFullName(String username); }
@Test public void testLoadUserAsync() throws InterruptedException { RestInvocations.loadProjectUsers(handler); handler.async(); projectUserService.loadUserAsync("tester", new NonDispatchTestCallback<User>(handler) { @Override public void evaluate(User user) { Assert.assertEquals("tester", user.getUsername()); Assert.assertEquals("Integration Test", user.getFullName()); } }); } @Test public void testLoadUserAsync_dispatch() throws InterruptedException { RestInvocations.loadProjectUsers(handler); handler.async(); projectUserService.loadUserAsync("tester", new DispatchTestCallback<User>(handler) { @Override public void evaluate(User user) { Assert.assertEquals("tester", user.getUsername()); Assert.assertEquals("Integration Test", user.getFullName()); } }); }
ProjectUserService extends AbstractCachingService<Integer, UserList, AbstractCachingService.Callback<UserList>> { public void loadUsersAsync(Callback<UserList> callback) { getValueAsync(1, callback); } ProjectUserService(Project project); void loadUsersAsync(Callback<UserList> callback); User tryGetUser(String username); void loadUserAsync(final String username, final Callback<User> callback); UserList getUserList(); User getUser(String username); String getUserFullName(String username); }
@Test public void testLoadUsersAsync() throws InterruptedException { RestInvocations.loadProjectUsers(handler); handler.async(); projectUserService.loadUsersAsync(new NonDispatchTestCallback<UserList>(handler) { @Override public void evaluate(UserList userList) { Assert.assertEquals(1, userList.size()); User tester = userList.getUser("tester"); Assert.assertEquals("tester", tester.getUsername()); Assert.assertEquals("Integration Test", tester.getFullName()); } }); }
ProjectUserService extends AbstractCachingService<Integer, UserList, AbstractCachingService.Callback<UserList>> { public String getUserFullName(String username) { User user = getUser(username); if(user != null) { return user.getFullName(); } else { return null; } } ProjectUserService(Project project); void loadUsersAsync(Callback<UserList> callback); User tryGetUser(String username); void loadUserAsync(final String username, final Callback<User> callback); UserList getUserList(); User getUser(String username); String getUserFullName(String username); }
@Test public void testGetUserFullName() { RestInvocations.loadProjectUsers(handler); String fullName = projectUserService.getUserFullName("tester"); Assert.assertEquals("Integration Test", fullName); projectUserService.getUserFullName("tester"); } @Test public void testGetUserFullName_nonexisting() { RestInvocations.loadProjectUsers(handler); String fullName = projectUserService.getUserFullName("nonexisting_tester"); Assert.assertNull(fullName); projectUserService.getUserFullName("nonexisting_tester"); }
AliRestClient implements RestClient { public static AliRestClient create(String location, String domain, String project, String userName, String password, SessionStrategy sessionStrategy) { return new AliRestClient(location, domain, project, userName, password, sessionStrategy); } private AliRestClient(String location, String domain, String project, String userName, String password, SessionStrategy sessionStrategy); static AliRestClient create(String location, String domain, String project, String userName, String password, SessionStrategy sessionStrategy); @Override void setTimeout(int timeout); @Override void setHttpProxy(String proxyHost, int proxyPort); @Override void setHttpProxyCredentials(String username, String password); @Override String getEncoding(); @Override SessionStrategy getSessionStrategy(); @Override void setEncoding(String encoding); @Override void setDomain(String domain); @Override void setProject(String project); @Override String getDomain(); @Override String getProject(); @Override List<Cookie> getCookies(String cookieName); @Override synchronized void login(); @Override synchronized void logout(); @Override String getForString(String template, Object... params); @Override InputStream getForStream(String template, Object... params); @Override int get(ResultInfo result, String template, Object... params); @Override int put(InputData inputData, ResultInfo result, String template, Object... params); @Override int delete(ResultInfo result, String template, Object... params); @Override int post(InputData data, ResultInfo result, String template, Object... params); @Override List<String> listDomains(); @Override List<String> listCurrentProjects(); static final Set<Integer> AUTH_FAIL_STATUSES; static final int DEFAULT_CLIENT_TIMEOUT; }
@Test public void testRequireDomainWhenProjectSpecified_create() { try { AliRestClient.create("http: Assert.fail("Domain is mandatory when project is specified."); } catch (IllegalArgumentException e) { } }
DevMotiveService { public Map<Commit, List<EntityRef>> getRelatedEntities(List<Commit> commits) { HashMap<Commit, List<EntityRef>> ret = new HashMap<Commit, List<EntityRef>>(); Integer workspaceId = workspaceConfiguration.getWorkspaceId(); if (workspaceId == null) { return noResponse(ret, commits); } Element commitsElem = new Element("commits"); for (Commit commit: commits) { Element commitElem = new Element("commit"); setAttribute(commitElem, "committer", commit.getCommitterEmail(), commit.getCommitterName()); setAttribute(commitElem, "author", commit.getAuthorEmail(), commit.getAuthorName()); commitElem.setAttribute("revision", commit.getRevisionString()); commitElem.setAttribute("date", CommentField.dateTimeFormat.format(commit.getDate())); Element messageElem = new Element("message"); messageElem.setText(commit.getMessage()); commitElem.addContent(messageElem); commitsElem.addContent(commitElem); } String commitRequest = XMLOutputterFactory.getXMLOutputter().outputString(new Document(commitsElem)); MyResultInfo result = new MyResultInfo(); int code = restService.post(commitRequest, result, "workspace/{0}/ali/linked-items/commits", workspaceId); if (code != HttpStatus.SC_OK) { return noResponse(ret, commits); } Iterator<CommitInfo> commitInfoIterator = CommitInfoList.create(result.getBodyAsStream()).iterator(); for (Commit commit: commits) { CommitInfo next = commitInfoIterator.next(); LinkedList<EntityRef> list; if (next.getId() != null) { list = new LinkedList<EntityRef>(); for (int id: next.getDefects()) { list.add(new EntityRef("defect", id)); } for (int id: next.getRequirements()) { list.add(new EntityRef("requirement", id)); } } else { list = null; } ret.put(commit, list); } return ret; } DevMotiveService(RestService restService, WorkspaceConfiguration workspaceConfiguration); Map<Commit, List<EntityRef>> getRelatedEntities(List<Commit> commits); }
@Test public void testGetRelatedEntities() throws IOException { handler.addRequest("POST", "/qcbin/rest/domains/domain/projects/project/workspace/1000/ali/linked-items/commits", 200) .expectXmlBody(handler.getContent("devMotiveServiceTest_input.xml")) .content("devMotiveServiceTest_output.xml"); Commit commit1 = new Commit(new MyFileRevision(new MyRevisionNumber("1"), "commit1", new Date(0)), "authorName1", "authorEmail1", "committerName1", "committerEmail1"); Commit commit2 = new Commit(new MyFileRevision(new MyRevisionNumber("2"), "commit2", new Date(1000)), "authorName2", "authorEmail2", null, null); Commit commit3 = new Commit(new MyFileRevision(new MyRevisionNumber("3"), "commit3", new Date(1000000)), "authorName3", null, "committerName3", null); Commit commit4 = new Commit(new MyFileRevision(new MyRevisionNumber("4"), "commit4", new Date(1000000000)), "authorName4", "authorEmail4", "committerName4", "committerEmail4"); Map<Commit, List<EntityRef>> result = devMotiveService.getRelatedEntities(Arrays.asList(commit1, commit2, commit3, commit4)); Assert.assertNull(result.get(commit1)); Assert.assertTrue(result.get(commit2).isEmpty()); Assert.assertEquals(Collections.singletonList(new EntityRef("defect", 1)), result.get(commit3)); Assert.assertEquals(Collections.singletonList(new EntityRef("requirement", 2)), result.get(commit4)); }
MetadataSimpleService extends AbstractCachingService<String, Metadata, AbstractCachingService.Callback<Metadata>> { Metadata getEntityMetadata(String entityType) { return getValue(entityType); } MetadataSimpleService(Project project); }
@Test public void testGetEntityMetadata() throws IOException { requests(); Metadata metadata = metadataSimpleService.getEntityMetadata("defect"); Assert.assertEquals("defect", metadata.getEntityType()); Assert.assertEquals(Integer.class, metadata.getField("id").getClazz()); Assert.assertEquals(metadata, metadataSimpleService.getEntityMetadata("defect")); }
MetadataSimpleService extends AbstractCachingService<String, Metadata, AbstractCachingService.Callback<Metadata>> { void getEntityMetadataAsync(String entityType, MetadataService.MetadataCallback callback) { getValueAsync(entityType, MetadataService.Proxy.create(callback)); } MetadataSimpleService(Project project); }
@Test public void testGetEntityMetadataAsync() throws InterruptedException, IOException { requests(); handler.async(); metadataSimpleService.getEntityMetadataAsync("defect", new MetadataService.MetadataCallback() { @Override public void metadataLoaded(final Metadata metadata) { handler.done(new Runnable() { @Override public void run() { Assert.assertFalse("Callback inside dispatch thread", SwingUtilities.isEventDispatchThread()); Assert.assertEquals("defect", metadata.getEntityType()); Assert.assertEquals(Integer.class, metadata.getField("id").getClazz()); Assert.assertEquals(metadata, metadataSimpleService.getEntityMetadata("defect")); final Thread t = Thread.currentThread(); metadataSimpleService.getEntityMetadataAsync("defect", new MetadataService.MetadataCallback() { @Override public void metadataLoaded(Metadata metadata) { Assert.assertEquals("Callback outside current thread although data should be cached", t, Thread.currentThread()); } @Override public void metadataFailed() { Assert.fail("Should have succeeded"); } }); } }); } @Override public void metadataFailed() { Assert.fail("Should have succeeded"); } }); } @Test public void testGetEntityMetadataAsync_failure() throws InterruptedException, IOException { handler.addRequest(false, "GET", "/qcbin/rest/domains/domain/projects/project/customization/entities/non-existing-type/fields", 404); handler.async(); metadataSimpleService.getEntityMetadataAsync("non-existing-type", new MetadataService.MetadataCallback() { @Override public void metadataLoaded(final Metadata metadata) { handler.fail("Should have failed for wrong entity type"); } @Override public void metadataFailed() { handler.done(); } }); }
WeakListeners { public void remove(E listener) { synchronized (listeners) { for(Iterator<MyReference<E>> it = listeners.iterator(); it.hasNext(); ) { E theListener = it.next().get(); if(theListener == null || theListener.equals(listener)) { it.remove(); } } } } void fire(Action<E> action); void add(E listener, boolean weak); void add(E listener); void remove(E listener); boolean isRegistered(E listener); }
@Test public void testRemove() throws InterruptedException { Listener listener = new Listener() { @Override public void exec() { Assert.fail("Should have been removed"); } }; weakListeners.add(listener); weakListeners.remove(listener); weakListeners.fire(new WeakListeners.Action<Listener>() { @Override public void fire(Listener listener) { listener.exec(); } }); }