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
WeakListeners { public boolean isRegistered(E listener) { synchronized (listeners) { for(Iterator<MyReference<E>> it = listeners.iterator(); it.hasNext(); ) { E theListener = it.next().get(); if(theListener == null) { it.remove(); } else if(theListener.equals(listener)) { return true; } } return false; } } 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 testIsRegistered() { Listener listener = new Listener() { @Override public void exec() { } }; Assert.assertFalse(weakListeners.isRegistered(listener)); weakListeners.add(listener, false); Assert.assertTrue(weakListeners.isRegistered(listener)); }
FavoritesService extends AbstractCachingService<FavoritesService.Favorite, EntityQuery, AbstractCachingService.Callback<EntityQuery>> { public EntityQuery getFavorite(int id, String entityType) { return getValue(new Favorite(id, entityType)); } FavoritesService(Project project, EntityService entityService, AliProjectConfiguration projConf, MetadataService metadataService, FilterManager filterManager, RestService restService); EntityQuery getFavorite(int id, String entityType); EntityQuery getStoredQuery(String entityType, String queryNameAndKind); List<EntityQuery> getAvailableQueries(String entityType); void unresolveQuery(EntityQuery query); }
@Test public void testGetFavorite() { RestInvocations.loadMetadata(handler, "favorite"); RestInvocations.loadMetadata(handler, "defect"); RestInvocations.loadMetadata(handler, "release-backlog-item"); handler.addRequest(false, "GET", "/qcbin/rest/domains/domain/projects/project/favorites?fields=&query={id[1014]}&order-by={}", 200) .content("favoritesServiceTest_favorite.xml"); EntityQuery query = favoritesService.getFavorite(1014, "defect"); checkQuery(query); }
FavoritesService extends AbstractCachingService<FavoritesService.Favorite, EntityQuery, AbstractCachingService.Callback<EntityQuery>> { public EntityQuery getStoredQuery(String entityType, String queryNameAndKind) { Matcher matcher = Pattern.compile("^(\\d+): .* \\(ALM\\)$").matcher(queryNameAndKind); if(matcher.matches()) { int id = Integer.valueOf(matcher.group(1)); return getFavorite(id, entityType); } else { for(EntityQuery filter: getAvailableQueries(entityType)) { if(queryNameAndKind.equals(filter.getName())) { return filter; } } return null; } } FavoritesService(Project project, EntityService entityService, AliProjectConfiguration projConf, MetadataService metadataService, FilterManager filterManager, RestService restService); EntityQuery getFavorite(int id, String entityType); EntityQuery getStoredQuery(String entityType, String queryNameAndKind); List<EntityQuery> getAvailableQueries(String entityType); void unresolveQuery(EntityQuery query); }
@Test public void testGetStoredQuery_server() { RestInvocations.loadMetadata(handler, "favorite"); RestInvocations.loadMetadata(handler, "defect"); RestInvocations.loadMetadata(handler, "release-backlog-item"); handler.addRequest(false, "GET", "/qcbin/rest/domains/domain/projects/project/favorites?fields=&query={id[1014]}&order-by={}", 200) .content("favoritesServiceTest_favorite.xml"); EntityQuery query = favoritesService.getStoredQuery("defect", "1014: blockers (ALM)"); checkQuery(query); } @Test public void testGetStoredQuery_serverInvalid() { RestInvocations.loadMetadata(handler, "favorite"); handler.addRequest("GET", "/qcbin/rest/domains/domain/projects/project/favorites?fields=&query={id[1015]}&order-by={}", 200) .content("no_entities.xml"); EntityQuery query = favoritesService.getStoredQuery("defect", "1015: something (ALM)"); Assert.assertNull(query); } @Test public void testGetStoredQuery_stored() { addStoredQuery(); EntityQuery query = favoritesService.getStoredQuery("defect", "test_query (project)"); Assert.assertEquals("1", query.getValue("id")); } @Test public void testGetStoredQuery_storedInvalid() { EntityQuery query = favoritesService.getStoredQuery("defect", "bad_test_query (project)"); Assert.assertNull(query); } @Test public void testGetGlobalQuery_stored() { addGlobalQuery(); EntityQuery query = favoritesService.getStoredQuery("defect", "global_test_query (global)"); Assert.assertEquals("1", query.getValue("id")); } @Test public void testGetGlobalQuery_storedInvalid() { EntityQuery query = favoritesService.getStoredQuery("defect", "global_bad_test_query (global)"); Assert.assertNull(query); }
AliRestClient implements RestClient { @Override public synchronized void login() { List<String> authPrefs = new ArrayList<String>(2); authPrefs.add(AuthPolicy.DIGEST); authPrefs.add(AuthPolicy.BASIC); httpClient.getParams().setParameter(AuthPolicy.AUTH_SCHEME_PRIORITY, authPrefs); String authPoint = pathJoin("/", location, "/authentication-point/alm-authenticate"); String authXml = createAuthXml(); PostMethod post = initPostMethod(authPoint, authXml); ResultInfo resultInfo = ResultInfo.create(null); executeAndWriteResponse(post, resultInfo, Collections.<Integer>emptySet()); if(resultInfo.getHttpStatus() == HttpStatus.SC_NOT_FOUND) { Credentials cred = new UsernamePasswordCredentials(userName, password); AuthScope scope = new AuthScope(AuthScope.ANY_HOST, AuthScope.ANY_PORT); httpClient.getParams().setParameter(HttpMethodParams.CREDENTIAL_CHARSET, "UTF-8"); httpClient.getState().setCredentials(scope, cred); authPoint = pathJoin("/", location, "/authentication-point/authenticate"); GetMethod get = new GetMethod(authPoint); resultInfo = ResultInfo.create(null); executeAndWriteResponse(get, resultInfo, Collections.<Integer>emptySet()); } HttpStatusBasedException.throwForError(resultInfo); if(resultInfo.getHttpStatus() != 200) { throw new AuthenticationFailureException(resultInfo); } Cookie[] cookies = httpClient.getState().getCookies(); Cookie ssoCookie = getSessionCookieByName(cookies, COOKIE_SSO_NAME); addTenantCookie(ssoCookie); String siteSessionPoint = pathJoin("/", location, "/rest/site-session"); String sessionParamXml = createRestSessionXml(); post = initPostMethod(siteSessionPoint, sessionParamXml); resultInfo = ResultInfo.create(null); executeAndWriteResponse(post, resultInfo, Collections.<Integer>emptySet()); if (resultInfo.getHttpStatus() != HttpStatus.SC_FORBIDDEN) { HttpStatusBasedException.throwForError(resultInfo); } cookies = httpClient.getState().getCookies(); Cookie qcCookie = getSessionCookieByName(cookies, COOKIE_SESSION_NAME); sessionContext = new SessionContext(location, ssoCookie, qcCookie); } 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 testLogin() throws Exception { handler.authenticate(); AliRestClient client = AliRestClient.create(handler.getQcUrl(), "domain", "project", "user", "password", RestClient.SessionStrategy.NONE); client.login(); }
FavoritesService extends AbstractCachingService<FavoritesService.Favorite, EntityQuery, AbstractCachingService.Callback<EntityQuery>> { public List<EntityQuery> getAvailableQueries(String entityType) { LinkedList<EntityQuery> list = new LinkedList<EntityQuery>(); process(list, projConf.getStoredFilters(entityType), "project"); process(list, aliConfiguration.getStoredFilters(entityType), "global"); return list; } FavoritesService(Project project, EntityService entityService, AliProjectConfiguration projConf, MetadataService metadataService, FilterManager filterManager, RestService restService); EntityQuery getFavorite(int id, String entityType); EntityQuery getStoredQuery(String entityType, String queryNameAndKind); List<EntityQuery> getAvailableQueries(String entityType); void unresolveQuery(EntityQuery query); }
@Test public void testGetAvailableQueries() { addStoredQuery(); addGlobalQuery(); List<EntityQuery> list = favoritesService.getAvailableQueries("defect"); Assert.assertEquals(2, list.size()); Assert.assertEquals("test_query (project)", list.get(0).getName()); Assert.assertEquals("1", list.get(0).getValue("id")); Assert.assertEquals("global_test_query (global)", list.get(1).getName()); Assert.assertEquals("1", list.get(1).getValue("id")); }
FavoritesService extends AbstractCachingService<FavoritesService.Favorite, EntityQuery, AbstractCachingService.Callback<EntityQuery>> { public void unresolveQuery(EntityQuery query) { for(String property: query.getPropertyMap().keySet()) { String realProperty = restService.getServerStrategy().getFieldAlias(query.getEntityType(), property); if(!property.equals(realProperty)) { query.setValue(realProperty, query.getValue(property)); query.setValue(property, null); } Field field = metadataService.getEntityMetadata(query.getEntityType()).getField(realProperty); FilterFactory factory = filterManager.getFilterFactory(new Context<EntityQuery>(query), query.getEntityType(), field, true); if(factory != null) { Node node = ExpressionParser.parse(query.getValue(realProperty)); List<String> values = new LinkedList<String>(); if(collectOrValues(node, values)) { query.setValue(realProperty, factory.multipleValues(values)); } } } } FavoritesService(Project project, EntityService entityService, AliProjectConfiguration projConf, MetadataService metadataService, FilterManager filterManager, RestService restService); EntityQuery getFavorite(int id, String entityType); EntityQuery getStoredQuery(String entityType, String queryNameAndKind); List<EntityQuery> getAvailableQueries(String entityType); void unresolveQuery(EntityQuery query); }
@Test public void testUnresolveQuery() { RestInvocations.loadMetadata(handler, "defect"); RestInvocations.loadMetadata(handler, "release-backlog-item"); EntityQuery query = new EntityQuery("defect"); query.setValue("status", "a OR b OR c"); query.setValue("owner", "me or you"); favoritesService.unresolveQuery(query); Assert.assertEquals("a;b;c", query.getValue("status")); Assert.assertEquals("me;you", query.getValue("release-backlog-item.owner")); Assert.assertNull(query.getValue("owner")); }
TeamService extends AbstractCachingEntityService<String> { public Entity getTeam(String teamName, int releaseId) { List<Entity> teams = getTeams(teamName); for(Entity team: teams) { if(team.getPropertyValue("release-id").equals(String.valueOf(releaseId))) { return team; } } return null; } TeamService(Project project, EntityService entityService); Entity getTeam(String teamName, int releaseId); List<Entity> getTeams(String teamName); EntityList getMultipleTeams(List<String> teamNames); }
@Test public void testGetTeam() { Entity team = teamService.getTeam("The Team", 1001); Assert.assertEquals(101, team.getId()); teamService.getTeam("The Team", 1001); }
TeamService extends AbstractCachingEntityService<String> { public List<Entity> getTeams(String teamName) { return getValue(teamName); } TeamService(Project project, EntityService entityService); Entity getTeam(String teamName, int releaseId); List<Entity> getTeams(String teamName); EntityList getMultipleTeams(List<String> teamNames); }
@Test public void testGetTeams() { List<Entity> list = teamService.getTeams("The Team"); Assert.assertEquals(2, list.size()); Assert.assertEquals(101, list.get(0).getId()); Assert.assertEquals("1000", list.get(0).getPropertyValue("release-id")); Assert.assertEquals(101, list.get(1).getId()); Assert.assertEquals("1001", list.get(1).getPropertyValue("release-id")); teamService.getTeams("The Team"); }
TeamService extends AbstractCachingEntityService<String> { public EntityList getMultipleTeams(List<String> teamNames) { EntityList entities = EntityList.empty(); for(String teamName: teamNames) { entities.addAll(getTeams(teamName)); } return entities; } TeamService(Project project, EntityService entityService); Entity getTeam(String teamName, int releaseId); List<Entity> getTeams(String teamName); EntityList getMultipleTeams(List<String> teamNames); }
@Test public void testGetMultipleTeams() { handler.addRequest("GET", "/qcbin/rest/domains/domain/projects/project/teams?fields=id,release-id,name&query={name['The Others']}&order-by={}", 200) .content("teamServiceTest_teams2.xml"); EntityList list = teamService.getMultipleTeams(Arrays.asList("The Team", "The Others")); Assert.assertEquals(3, list.size()); Assert.assertEquals(101, list.get(0).getId()); Assert.assertEquals("1000", list.get(0).getPropertyValue("release-id")); Assert.assertEquals(101, list.get(1).getId()); Assert.assertEquals("1001", list.get(1).getPropertyValue("release-id")); Assert.assertEquals(102, list.get(2).getId()); Assert.assertEquals("1001", list.get(2).getPropertyValue("release-id")); teamService.getMultipleTeams(Arrays.asList("The Team", "The Others")); }
SprintService implements PersistentStateComponent<Element>, ServerTypeListener, CachingEntityListener { public Element getState() { Element element = new Element(getClass().getSimpleName()); addElement(element, releaseSelector.selected); addElement(element, sprintSelector.selected); addElement(element, teamSelector.selected); return element; } SprintService(Project project); Element getState(); void loadState(Element state); @Override void connectedTo(ServerType serverType); synchronized Entity getRelease(); synchronized Entity getSprint(); synchronized Entity getTeam(); void addListener(Listener listener); void removeListener(Listener listener); synchronized void selectRelease(final Entity release); synchronized void selectSprint(Entity sprint); synchronized void selectTeam(Entity team); synchronized Entity getCurrentSprint(); synchronized EntityList getTeams(); EntityList getSprints(); EntityList getReleases(); static boolean isSameTense(Entity sprint1, Entity sprint2); static boolean isCurrentSprint(Entity sprint); static long distance(long now, Entity entity); @Override Entity lookup(final EntityRef ref); @Override void entityLoaded(Entity entity, Event event); @Override void entityNotFound(EntityRef ref, boolean removed); }
@Test public void testGetState() throws Throwable { selectTestRelease(); Element state = sprintService.getState(); Assert.assertEquals("SprintService", state.getName()); Assert.assertEquals("1001", state.getAttributeValue("release-id")); Assert.assertEquals("Test Release", state.getAttributeValue("release-name")); Assert.assertEquals("1002", state.getAttributeValue("release-cycle-id")); Assert.assertEquals("Sprint 2", state.getAttributeValue("release-cycle-name")); Assert.assertEquals("101", state.getAttributeValue("team-id")); Assert.assertEquals("The Team", state.getAttributeValue("team-name")); } @Test public void testGetState_None() throws Throwable { Element state = sprintService.getState(); Assert.assertEquals("SprintService", state.getName()); Assert.assertNull(state.getAttributeValue("release-id")); Assert.assertNull(state.getAttributeValue("release-name")); Assert.assertNull(state.getAttributeValue("release-cycle-id")); Assert.assertNull(state.getAttributeValue("release-cycle-name")); Assert.assertNull(state.getAttributeValue("team-id")); Assert.assertNull(state.getAttributeValue("team-name")); }
AliRestClient implements RestClient { @Override public void setHttpProxy(String proxyHost, int proxyPort) { httpClient.getHostConfiguration().setProxy(proxyHost, proxyPort); } 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 testSetHttpProxy() throws Exception { handler.authenticate(); handler.addRequest("GET", "/qcbin/rest/domains/domain/projects/project/test", 200); AliRestClient client = AliRestClient.create("http: client.setHttpProxy("localhost", ((ServerConnector)handler.getServer().getConnectors()[0]).getLocalPort()); client.getForStream("/test"); }
SprintService implements PersistentStateComponent<Element>, ServerTypeListener, CachingEntityListener { public void loadState(Element state) { selectSprint(loadEntity(state, "release-cycle")); selectTeam(loadEntity(state, "team")); selectRelease(loadEntity(state, "release")); } SprintService(Project project); Element getState(); void loadState(Element state); @Override void connectedTo(ServerType serverType); synchronized Entity getRelease(); synchronized Entity getSprint(); synchronized Entity getTeam(); void addListener(Listener listener); void removeListener(Listener listener); synchronized void selectRelease(final Entity release); synchronized void selectSprint(Entity sprint); synchronized void selectTeam(Entity team); synchronized Entity getCurrentSprint(); synchronized EntityList getTeams(); EntityList getSprints(); EntityList getReleases(); static boolean isSameTense(Entity sprint1, Entity sprint2); static boolean isCurrentSprint(Entity sprint); static long distance(long now, Entity entity); @Override Entity lookup(final EntityRef ref); @Override void entityLoaded(Entity entity, Event event); @Override void entityNotFound(EntityRef ref, boolean removed); }
@Test public void testLoadState() throws Throwable { sprintTeamRequests_TestRelease(handler); WaitForEventsListener listener = new WaitForEventsListener(sprintService); Element state = new Element("SprintService"); state.setAttribute("release-id", "1001"); state.setAttribute("release-name", "Test Release"); state.setAttribute("release-cycle-id", "1001"); state.setAttribute("release-cycle-name", "Sprint 1"); state.setAttribute("team-id", "101"); state.setAttribute("team-name", "The Team"); sprintService.loadState(state); handler.consume(); listener.waitForEvents(1001, 1001, 101); Assert.assertEquals(1001, sprintService.getRelease().getId()); Assert.assertEquals(1001, sprintService.getSprint().getId()); Assert.assertEquals(101, sprintService.getTeam().getId()); }
SprintService implements PersistentStateComponent<Element>, ServerTypeListener, CachingEntityListener { @Override public void connectedTo(ServerType serverType) { if(ServerType.AGM.equals(restService.getServerTypeIfAvailable())) { synchronized (this) { resetValues(); final Entity release = this.releaseSelector.selected; if(release != null) { teamSelector.requestRunning = true; sprintSelector.requestRunning = true; releaseSelector.requestRunning = true; ApplicationManager.getApplication().executeOnPooledThread(new Runnable() { @Override public void run() { loadTeams(release); loadSprints(release); loadReleases(); } }); } else { this.releaseSelector.requestRunning = true; ApplicationManager.getApplication().executeOnPooledThread(new Runnable() { @Override public void run() { loadReleases(); } }); } } } } SprintService(Project project); Element getState(); void loadState(Element state); @Override void connectedTo(ServerType serverType); synchronized Entity getRelease(); synchronized Entity getSprint(); synchronized Entity getTeam(); void addListener(Listener listener); void removeListener(Listener listener); synchronized void selectRelease(final Entity release); synchronized void selectSprint(Entity sprint); synchronized void selectTeam(Entity team); synchronized Entity getCurrentSprint(); synchronized EntityList getTeams(); EntityList getSprints(); EntityList getReleases(); static boolean isSameTense(Entity sprint1, Entity sprint2); static boolean isCurrentSprint(Entity sprint); static long distance(long now, Entity entity); @Override Entity lookup(final EntityRef ref); @Override void entityLoaded(Entity entity, Event event); @Override void entityNotFound(EntityRef ref, boolean removed); }
@Test public void testConnectedTo() throws Throwable { selectTestRelease(); RestInvocations.getAuthenticationInfo(handler); releaseSprintTeamRequests_TestRelease(handler); getComponent(RestService.class).setServerType(ServerType.AGM); handler.consume(); }
SprintService implements PersistentStateComponent<Element>, ServerTypeListener, CachingEntityListener { public synchronized void selectRelease(final Entity release) { if((release != null && release.equals(this.releaseSelector.selected)) || (release == null && this.releaseSelector.selected == null)) { return; } this.releaseSelector.selected = release; if(release != null) { if(ServerType.AGM.equals(restService.getServerTypeIfAvailable())) { sprintSelector.requestRunning = true; teamSelector.requestRunning = true; ApplicationManager.getApplication().executeOnPooledThread(new Runnable() { @Override public void run() { loadSprints(release); loadTeams(release); } }); } } else { selectSprint(null); selectTeam(null); } fireReleaseSelected(); } SprintService(Project project); Element getState(); void loadState(Element state); @Override void connectedTo(ServerType serverType); synchronized Entity getRelease(); synchronized Entity getSprint(); synchronized Entity getTeam(); void addListener(Listener listener); void removeListener(Listener listener); synchronized void selectRelease(final Entity release); synchronized void selectSprint(Entity sprint); synchronized void selectTeam(Entity team); synchronized Entity getCurrentSprint(); synchronized EntityList getTeams(); EntityList getSprints(); EntityList getReleases(); static boolean isSameTense(Entity sprint1, Entity sprint2); static boolean isCurrentSprint(Entity sprint); static long distance(long now, Entity entity); @Override Entity lookup(final EntityRef ref); @Override void entityLoaded(Entity entity, Event event); @Override void entityNotFound(EntityRef ref, boolean removed); }
@Test public void testSelectRelease() throws Throwable { WaitForEventsListener listener = new WaitForEventsListener(sprintService); sprintTeamRequests_TestRelease(handler); sprintService.selectRelease(new Entity("release", 1001)); listener.waitForEvents(1001, 1002, 101); } @Test public void testSelectRelease_None() throws Throwable { selectTestRelease(); WaitForEventsListener listener = new WaitForEventsListener(sprintService); sprintService.selectRelease(null); listener.waitForEvents(null, null, null); }
SprintService implements PersistentStateComponent<Element>, ServerTypeListener, CachingEntityListener { public synchronized void selectSprint(Entity sprint) { if((sprint != null && sprint.equals(this.sprintSelector.selected) && isSameTense(sprint, this.sprintSelector.selected)) || (sprint == null && this.sprintSelector.selected == null)) { return; } this.sprintSelector.selected = sprint; fireSprintSelected(); } SprintService(Project project); Element getState(); void loadState(Element state); @Override void connectedTo(ServerType serverType); synchronized Entity getRelease(); synchronized Entity getSprint(); synchronized Entity getTeam(); void addListener(Listener listener); void removeListener(Listener listener); synchronized void selectRelease(final Entity release); synchronized void selectSprint(Entity sprint); synchronized void selectTeam(Entity team); synchronized Entity getCurrentSprint(); synchronized EntityList getTeams(); EntityList getSprints(); EntityList getReleases(); static boolean isSameTense(Entity sprint1, Entity sprint2); static boolean isCurrentSprint(Entity sprint); static long distance(long now, Entity entity); @Override Entity lookup(final EntityRef ref); @Override void entityLoaded(Entity entity, Event event); @Override void entityNotFound(EntityRef ref, boolean removed); }
@Test public void testSelectSprint() throws Throwable { selectTestRelease(); WaitForEventsListener listener = new WaitForEventsListener(sprintService, false, true, false); sprintService.selectSprint(new Entity("release-cycle", 1001)); listener.waitForEvents(null, 1001, null); }
SprintService implements PersistentStateComponent<Element>, ServerTypeListener, CachingEntityListener { public synchronized void selectTeam(Entity team) { if((team != null && team.equals(this.teamSelector.selected)) || (team == null && this.teamSelector.selected == null)) { return; } this.teamSelector.selected = team; fireTeamSelected(); } SprintService(Project project); Element getState(); void loadState(Element state); @Override void connectedTo(ServerType serverType); synchronized Entity getRelease(); synchronized Entity getSprint(); synchronized Entity getTeam(); void addListener(Listener listener); void removeListener(Listener listener); synchronized void selectRelease(final Entity release); synchronized void selectSprint(Entity sprint); synchronized void selectTeam(Entity team); synchronized Entity getCurrentSprint(); synchronized EntityList getTeams(); EntityList getSprints(); EntityList getReleases(); static boolean isSameTense(Entity sprint1, Entity sprint2); static boolean isCurrentSprint(Entity sprint); static long distance(long now, Entity entity); @Override Entity lookup(final EntityRef ref); @Override void entityLoaded(Entity entity, Event event); @Override void entityNotFound(EntityRef ref, boolean removed); }
@Test public void testSelectTeam() throws Throwable { selectTestRelease(); WaitForEventsListener listener = new WaitForEventsListener(sprintService, false, false, true); sprintService.selectTeam(new Entity("team", 102)); listener.waitForEvents(null, null, 102); }
SprintService implements PersistentStateComponent<Element>, ServerTypeListener, CachingEntityListener { public EntityList getReleases() { return getValues(releaseSelector, new Runnable() { @Override public void run() { loadReleases(); } }); } SprintService(Project project); Element getState(); void loadState(Element state); @Override void connectedTo(ServerType serverType); synchronized Entity getRelease(); synchronized Entity getSprint(); synchronized Entity getTeam(); void addListener(Listener listener); void removeListener(Listener listener); synchronized void selectRelease(final Entity release); synchronized void selectSprint(Entity sprint); synchronized void selectTeam(Entity team); synchronized Entity getCurrentSprint(); synchronized EntityList getTeams(); EntityList getSprints(); EntityList getReleases(); static boolean isSameTense(Entity sprint1, Entity sprint2); static boolean isCurrentSprint(Entity sprint); static long distance(long now, Entity entity); @Override Entity lookup(final EntityRef ref); @Override void entityLoaded(Entity entity, Event event); @Override void entityNotFound(EntityRef ref, boolean removed); }
@Test public void testGetReleases() throws Throwable { sprintService.resetValues(); releaseSprintTeamRequests_TestRelease(handler); for(int i = 0; i < 3; i++) { handler.async(); ApplicationManager.getApplication().executeOnPooledThread(new Runnable() { @Override public void run() { final EntityList releases = sprintService.getReleases(); handler.done(new Runnable() { @Override public void run() { Assert.assertEquals(2, releases.size()); Assert.assertEquals(1001, releases.get(0).getId()); Assert.assertEquals(1000, releases.get(1).getId()); } }); } }); } handler.consume(); }
SprintService implements PersistentStateComponent<Element>, ServerTypeListener, CachingEntityListener { public EntityList getSprints() { final Entity release = this.releaseSelector.selected; if(release != null) { return getValues(sprintSelector, new Runnable() { @Override public void run() { loadSprints(release); } }); } else { return null; } } SprintService(Project project); Element getState(); void loadState(Element state); @Override void connectedTo(ServerType serverType); synchronized Entity getRelease(); synchronized Entity getSprint(); synchronized Entity getTeam(); void addListener(Listener listener); void removeListener(Listener listener); synchronized void selectRelease(final Entity release); synchronized void selectSprint(Entity sprint); synchronized void selectTeam(Entity team); synchronized Entity getCurrentSprint(); synchronized EntityList getTeams(); EntityList getSprints(); EntityList getReleases(); static boolean isSameTense(Entity sprint1, Entity sprint2); static boolean isCurrentSprint(Entity sprint); static long distance(long now, Entity entity); @Override Entity lookup(final EntityRef ref); @Override void entityLoaded(Entity entity, Event event); @Override void entityNotFound(EntityRef ref, boolean removed); }
@Test public void testGetSprints() throws Throwable { selectTestRelease(); sprintService.resetValues(); sprintRequests_TestRelease(handler); for(int i = 0; i < 3; i++) { handler.async(); ApplicationManager.getApplication().executeOnPooledThread(new Runnable() { @Override public void run() { final EntityList sprints = sprintService.getSprints(); handler.done(new Runnable() { @Override public void run() { Assert.assertEquals(2, sprints.size()); Assert.assertEquals(1001, sprints.get(0).getId()); Assert.assertEquals(1002, sprints.get(1).getId()); } }); } }); } handler.consume(); }
SprintService implements PersistentStateComponent<Element>, ServerTypeListener, CachingEntityListener { public synchronized EntityList getTeams() { final Entity release = this.releaseSelector.selected; if(release != null) { return getValues(teamSelector, new Runnable() { @Override public void run() { loadTeams(release); } }); } else { return null; } } SprintService(Project project); Element getState(); void loadState(Element state); @Override void connectedTo(ServerType serverType); synchronized Entity getRelease(); synchronized Entity getSprint(); synchronized Entity getTeam(); void addListener(Listener listener); void removeListener(Listener listener); synchronized void selectRelease(final Entity release); synchronized void selectSprint(Entity sprint); synchronized void selectTeam(Entity team); synchronized Entity getCurrentSprint(); synchronized EntityList getTeams(); EntityList getSprints(); EntityList getReleases(); static boolean isSameTense(Entity sprint1, Entity sprint2); static boolean isCurrentSprint(Entity sprint); static long distance(long now, Entity entity); @Override Entity lookup(final EntityRef ref); @Override void entityLoaded(Entity entity, Event event); @Override void entityNotFound(EntityRef ref, boolean removed); }
@Test public void testGetTeams() throws Throwable { selectTestRelease(); sprintService.resetValues(); teamRequests_TestRelease(handler); for(int i = 0; i < 3; i++) { handler.async(); ApplicationManager.getApplication().executeOnPooledThread(new Runnable() { @Override public void run() { final EntityList teams = sprintService.getTeams(); handler.done(new Runnable() { @Override public void run() { Assert.assertEquals(2, teams.size()); Assert.assertEquals(101, teams.get(0).getId()); Assert.assertEquals(102, teams.get(1).getId()); } }); } }); } handler.consume(); }
SprintService implements PersistentStateComponent<Element>, ServerTypeListener, CachingEntityListener { public synchronized Entity getRelease() { return releaseSelector.selected; } SprintService(Project project); Element getState(); void loadState(Element state); @Override void connectedTo(ServerType serverType); synchronized Entity getRelease(); synchronized Entity getSprint(); synchronized Entity getTeam(); void addListener(Listener listener); void removeListener(Listener listener); synchronized void selectRelease(final Entity release); synchronized void selectSprint(Entity sprint); synchronized void selectTeam(Entity team); synchronized Entity getCurrentSprint(); synchronized EntityList getTeams(); EntityList getSprints(); EntityList getReleases(); static boolean isSameTense(Entity sprint1, Entity sprint2); static boolean isCurrentSprint(Entity sprint); static long distance(long now, Entity entity); @Override Entity lookup(final EntityRef ref); @Override void entityLoaded(Entity entity, Event event); @Override void entityNotFound(EntityRef ref, boolean removed); }
@Test public void testGetRelease() throws Throwable { selectTestRelease(); Assert.assertEquals(1001, sprintService.getRelease().getId()); }
AliRestClient implements RestClient { @Override public void setHttpProxyCredentials(String username, String password) { Credentials cred = new UsernamePasswordCredentials(username, password); AuthScope scope = new AuthScope(AuthScope.ANY_HOST, AuthScope.ANY_PORT); httpClient.getState().setProxyCredentials(scope, cred); } 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 testSetHttpProxyCredentials() throws Exception { handler.addRequest("POST", "/qcbin/authentication-point/alm-authenticate", 407) .responseHeader("Proxy-Authenticate", "Basic realm=\"proxy realm\"") .responseBody("Proxy Authentication Required"); handler.addRequest("POST", "/qcbin/authentication-point/alm-authenticate", 200) .expectHeader("Proxy-Authorization", "Basic dXNlcm5hbWU6cGFzc3dvcmQ=") .expectXmlBody("<alm-authentication><user>qc_user</user><password>qc_password</password></alm-authentication>"); handler.addRequest("POST", "/qcbin/rest/site-session", 200) .expectXmlBody("<session-parameters><client-type>ALI_IDEA_plugin</client-type></session-parameters>"); handler.addRequest("GET", "/qcbin/rest/domains/domain/projects/project/test", 200); AliRestClient client = AliRestClient.create("http: client.setHttpProxy("localhost", ((ServerConnector)handler.getServer().getConnectors()[0]).getLocalPort()); client.setHttpProxyCredentials("username", "password"); client.getForStream("/test"); }
SprintService implements PersistentStateComponent<Element>, ServerTypeListener, CachingEntityListener { public synchronized Entity getSprint() { return sprintSelector.selected; } SprintService(Project project); Element getState(); void loadState(Element state); @Override void connectedTo(ServerType serverType); synchronized Entity getRelease(); synchronized Entity getSprint(); synchronized Entity getTeam(); void addListener(Listener listener); void removeListener(Listener listener); synchronized void selectRelease(final Entity release); synchronized void selectSprint(Entity sprint); synchronized void selectTeam(Entity team); synchronized Entity getCurrentSprint(); synchronized EntityList getTeams(); EntityList getSprints(); EntityList getReleases(); static boolean isSameTense(Entity sprint1, Entity sprint2); static boolean isCurrentSprint(Entity sprint); static long distance(long now, Entity entity); @Override Entity lookup(final EntityRef ref); @Override void entityLoaded(Entity entity, Event event); @Override void entityNotFound(EntityRef ref, boolean removed); }
@Test public void testGetSprint() throws Throwable { selectTestRelease(); Assert.assertEquals(1002, sprintService.getSprint().getId()); }
SprintService implements PersistentStateComponent<Element>, ServerTypeListener, CachingEntityListener { public synchronized Entity getTeam() { return teamSelector.selected; } SprintService(Project project); Element getState(); void loadState(Element state); @Override void connectedTo(ServerType serverType); synchronized Entity getRelease(); synchronized Entity getSprint(); synchronized Entity getTeam(); void addListener(Listener listener); void removeListener(Listener listener); synchronized void selectRelease(final Entity release); synchronized void selectSprint(Entity sprint); synchronized void selectTeam(Entity team); synchronized Entity getCurrentSprint(); synchronized EntityList getTeams(); EntityList getSprints(); EntityList getReleases(); static boolean isSameTense(Entity sprint1, Entity sprint2); static boolean isCurrentSprint(Entity sprint); static long distance(long now, Entity entity); @Override Entity lookup(final EntityRef ref); @Override void entityLoaded(Entity entity, Event event); @Override void entityNotFound(EntityRef ref, boolean removed); }
@Test public void testGetTeam() throws Throwable { selectTestRelease(); Assert.assertEquals(101, sprintService.getTeam().getId()); }
SprintService implements PersistentStateComponent<Element>, ServerTypeListener, CachingEntityListener { public synchronized Entity getCurrentSprint() { if(sprintSelector.values == null) { return null; } for(Entity sprint: sprintSelector.values) { if(isCurrentSprint(sprint)) { return sprint; } } return null; } SprintService(Project project); Element getState(); void loadState(Element state); @Override void connectedTo(ServerType serverType); synchronized Entity getRelease(); synchronized Entity getSprint(); synchronized Entity getTeam(); void addListener(Listener listener); void removeListener(Listener listener); synchronized void selectRelease(final Entity release); synchronized void selectSprint(Entity sprint); synchronized void selectTeam(Entity team); synchronized Entity getCurrentSprint(); synchronized EntityList getTeams(); EntityList getSprints(); EntityList getReleases(); static boolean isSameTense(Entity sprint1, Entity sprint2); static boolean isCurrentSprint(Entity sprint); static long distance(long now, Entity entity); @Override Entity lookup(final EntityRef ref); @Override void entityLoaded(Entity entity, Event event); @Override void entityNotFound(EntityRef ref, boolean removed); }
@Test public void testGetCurrentSprint() throws Throwable { selectTestRelease(); Assert.assertEquals(1002, sprintService.getCurrentSprint().getId()); } @Test public void testGetCurrentSprint_notMatching() throws Throwable { Assert.assertNull(sprintService.getCurrentSprint()); }
SprintService implements PersistentStateComponent<Element>, ServerTypeListener, CachingEntityListener { public static boolean isCurrentSprint(Entity sprint) { return "CURRENT".equalsIgnoreCase(sprint.getPropertyValue("tense")); } SprintService(Project project); Element getState(); void loadState(Element state); @Override void connectedTo(ServerType serverType); synchronized Entity getRelease(); synchronized Entity getSprint(); synchronized Entity getTeam(); void addListener(Listener listener); void removeListener(Listener listener); synchronized void selectRelease(final Entity release); synchronized void selectSprint(Entity sprint); synchronized void selectTeam(Entity team); synchronized Entity getCurrentSprint(); synchronized EntityList getTeams(); EntityList getSprints(); EntityList getReleases(); static boolean isSameTense(Entity sprint1, Entity sprint2); static boolean isCurrentSprint(Entity sprint); static long distance(long now, Entity entity); @Override Entity lookup(final EntityRef ref); @Override void entityLoaded(Entity entity, Event event); @Override void entityNotFound(EntityRef ref, boolean removed); }
@Test public void testIsCurrentSprint() throws Throwable { Entity sprint = new Entity("release-cycle", 1); sprint.setProperty("tense", "PAST"); Assert.assertFalse(SprintService.isCurrentSprint(sprint)); sprint.setProperty("tense", "CURRENT"); Assert.assertTrue(SprintService.isCurrentSprint(sprint)); sprint.setProperty("tense", "FUTURE"); Assert.assertFalse(SprintService.isCurrentSprint(sprint)); }
SprintService implements PersistentStateComponent<Element>, ServerTypeListener, CachingEntityListener { public static long distance(long now, Entity entity) { try { Date startDate = ALM_DATE_FORMAT.parse(entity.getPropertyValue("start-date")); if(now < startDate.getTime()) { return startDate.getTime() - now; } Date endDate = ALM_DATE_FORMAT.parse(entity.getPropertyValue("end-date")); Calendar calendar = Calendar.getInstance(); calendar.setTime(endDate); calendar.add(Calendar.DATE, 1); endDate = calendar.getTime(); if(now > endDate.getTime()) { return now - endDate.getTime(); } return 0; } catch(Exception e) { return Long.MAX_VALUE; } } SprintService(Project project); Element getState(); void loadState(Element state); @Override void connectedTo(ServerType serverType); synchronized Entity getRelease(); synchronized Entity getSprint(); synchronized Entity getTeam(); void addListener(Listener listener); void removeListener(Listener listener); synchronized void selectRelease(final Entity release); synchronized void selectSprint(Entity sprint); synchronized void selectTeam(Entity team); synchronized Entity getCurrentSprint(); synchronized EntityList getTeams(); EntityList getSprints(); EntityList getReleases(); static boolean isSameTense(Entity sprint1, Entity sprint2); static boolean isCurrentSprint(Entity sprint); static long distance(long now, Entity entity); @Override Entity lookup(final EntityRef ref); @Override void entityLoaded(Entity entity, Event event); @Override void entityNotFound(EntityRef ref, boolean removed); }
@Test public void testDistance() throws Throwable { Entity sprint = new Entity("release-cycle", 1); Assert.assertEquals(Long.MAX_VALUE, SprintService.distance(new Date().getTime(), sprint)); sprint.setProperty("start-date", "2013-05-02"); sprint.setProperty("end-date", "2013-05-09"); SimpleDateFormat format = new SimpleDateFormat("yyyy-MM-dd hh:mm:ss"); Assert.assertEquals(1000, SprintService.distance(format.parse("2013-05-01 23:59:59").getTime(), sprint)); Assert.assertEquals(1000, SprintService.distance(format.parse("2013-05-10 00:00:01").getTime(), sprint)); Assert.assertEquals(0, SprintService.distance(format.parse("2013-05-07 13:12:11").getTime(), sprint)); }
SprintService implements PersistentStateComponent<Element>, ServerTypeListener, CachingEntityListener { @Override public Entity lookup(final EntityRef ref) { if("release".equals(ref.type)) { return find(releaseSelector, ref); } else if("release-cycle".equals(ref.type)) { return find(sprintSelector, ref); } else if("team".equals(ref.type)) { return find(teamSelector, ref); } else { return null; } } SprintService(Project project); Element getState(); void loadState(Element state); @Override void connectedTo(ServerType serverType); synchronized Entity getRelease(); synchronized Entity getSprint(); synchronized Entity getTeam(); void addListener(Listener listener); void removeListener(Listener listener); synchronized void selectRelease(final Entity release); synchronized void selectSprint(Entity sprint); synchronized void selectTeam(Entity team); synchronized Entity getCurrentSprint(); synchronized EntityList getTeams(); EntityList getSprints(); EntityList getReleases(); static boolean isSameTense(Entity sprint1, Entity sprint2); static boolean isCurrentSprint(Entity sprint); static long distance(long now, Entity entity); @Override Entity lookup(final EntityRef ref); @Override void entityLoaded(Entity entity, Event event); @Override void entityNotFound(EntityRef ref, boolean removed); }
@Test public void testLookup() throws Throwable { selectTestRelease(); Assert.assertEquals("Test Release", sprintService.lookup(new EntityRef("release", 1001)).getPropertyValue("name")); Assert.assertEquals("Sprint 2", sprintService.lookup(new EntityRef("release-cycle", 1002)).getPropertyValue("name")); Assert.assertEquals("The Others", sprintService.lookup(new EntityRef("team", 102)).getPropertyValue("name")); Assert.assertNull(sprintService.lookup(new EntityRef("defect", 1))); sprintService.resetValues(); Assert.assertNull(sprintService.lookup(new EntityRef("release", 1001))); Assert.assertNull(sprintService.lookup(new EntityRef("release-cycle", 1002))); Assert.assertNull(sprintService.lookup(new EntityRef("team", 102))); Assert.assertNull(sprintService.lookup(new EntityRef("defect", 1))); }
EntityService { public Entity getEntity(EntityRef ref) { EntityQuery query = new EntityQuery(ref.type); Metadata metadata = metadataService.getEntityMetadata(ref.type); for(Field field: metadata.getAllFields().values()) { query.addColumn(field.getName(), 1); } query.setValue("id", String.valueOf(ref.id)); query.setPropertyResolved("id", true); EntityList list = doQuery(query, true); if(list.isEmpty()) { throw new RuntimeException("Entity not found: "+ref); } else { return list.get(0); } } EntityService(Project project, RestService restService, MetadataService metadataService, ErrorService errorService); void addEntityListener(EntityListener listener); void removeEntityListener(EntityListener listener); void refreshEntity(EntityRef ref); void getEntityAsync(EntityRef ref, EntityListener callback); Entity getEntity(EntityRef ref); EntityList query(EntityQuery query); InputStream queryForStream(EntityQuery query); Entity getDefectLink(int defectId, int linkId); Entity updateEntity(Entity entity, Set<String> fieldsToUpdate, boolean silent); Entity updateEntity(Entity entity, Set<String> fieldsToUpdate, boolean silent, boolean reloadOnFailure); Entity updateEntity(Entity entity, Set<String> fieldsToUpdate, boolean silent, boolean reloadOnFailure, boolean fireUpdate); Entity createEntity(Entity entity, boolean silent); Entity lockEntity(Entity entity, boolean silent); boolean deleteEntity(Entity entity); void unlockEntity(Entity entity); void fireEntityLoaded(final Entity entity, final EntityListener.Event event); void fireEntityNotFound(final EntityRef ref, final boolean removed); void requestCachedEntity(final EntityRef ref, final List<String> properties, final EntityListener callback); }
@Test @TestTarget(ServerVersion.AGM) public void testGetEntity() { 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"); Entity defect = entityService.getEntity(new EntityRef("defect", 86)); Assert.assertEquals(86, defect.getId()); 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"); try{ entityService.getEntity(new EntityRef("defect", 87)); Assert.fail("should have failed"); } catch (Exception e) { Assert.assertEquals("Entity not found: defect #87", e.getMessage()); } }
EntityService { public EntityList query(EntityQuery query) { return doQuery(query, false); } EntityService(Project project, RestService restService, MetadataService metadataService, ErrorService errorService); void addEntityListener(EntityListener listener); void removeEntityListener(EntityListener listener); void refreshEntity(EntityRef ref); void getEntityAsync(EntityRef ref, EntityListener callback); Entity getEntity(EntityRef ref); EntityList query(EntityQuery query); InputStream queryForStream(EntityQuery query); Entity getDefectLink(int defectId, int linkId); Entity updateEntity(Entity entity, Set<String> fieldsToUpdate, boolean silent); Entity updateEntity(Entity entity, Set<String> fieldsToUpdate, boolean silent, boolean reloadOnFailure); Entity updateEntity(Entity entity, Set<String> fieldsToUpdate, boolean silent, boolean reloadOnFailure, boolean fireUpdate); Entity createEntity(Entity entity, boolean silent); Entity lockEntity(Entity entity, boolean silent); boolean deleteEntity(Entity entity); void unlockEntity(Entity entity); void fireEntityLoaded(final Entity entity, final EntityListener.Event event); void fireEntityNotFound(final EntityRef ref, final boolean removed); void requestCachedEntity(final EntityRef ref, final List<String> properties, final EntityListener callback); }
@Test @TestTarget(ServerVersion.AGM) public void testQuery() { RestInvocations.loadMetadata(handler, "defect"); RestInvocations.loadMetadata(handler, "release-backlog-item"); handler.addRequest(false, "GET", "/qcbin/rest/domains/domain/projects/project/defects?fields=priority,release-backlog-item.id,release-backlog-item.blocked,product-group-id&query={status[\"Fixed\"]; product-group-id[1000]}&order-by={priority[DESC]}", 200) .content("entityServiceTest_entity.xml"); EntityQuery query = new EntityQuery("defect"); query.setValue("status", "Fixed"); query.addColumn("priority", 1); query.addOrder("priority", SortOrder.DESCENDING); EntityList list = entityService.query(query); Assert.assertEquals(1, list.size()); Assert.assertEquals(86, list.get(0).getId()); }
EntityService { public InputStream queryForStream(EntityQuery query) { EntityRef parent = query.getParent(); if(parent == null) { return restService.getForStream("{0}s?{1}", query.getEntityType(), queryToString(query)); } else { return restService.getForStream("{0}s/{1}/{2}s?{3}", parent.type, parent.id, query.getEntityType(), queryToString(query)); } } EntityService(Project project, RestService restService, MetadataService metadataService, ErrorService errorService); void addEntityListener(EntityListener listener); void removeEntityListener(EntityListener listener); void refreshEntity(EntityRef ref); void getEntityAsync(EntityRef ref, EntityListener callback); Entity getEntity(EntityRef ref); EntityList query(EntityQuery query); InputStream queryForStream(EntityQuery query); Entity getDefectLink(int defectId, int linkId); Entity updateEntity(Entity entity, Set<String> fieldsToUpdate, boolean silent); Entity updateEntity(Entity entity, Set<String> fieldsToUpdate, boolean silent, boolean reloadOnFailure); Entity updateEntity(Entity entity, Set<String> fieldsToUpdate, boolean silent, boolean reloadOnFailure, boolean fireUpdate); Entity createEntity(Entity entity, boolean silent); Entity lockEntity(Entity entity, boolean silent); boolean deleteEntity(Entity entity); void unlockEntity(Entity entity); void fireEntityLoaded(final Entity entity, final EntityListener.Event event); void fireEntityNotFound(final EntityRef ref, final boolean removed); void requestCachedEntity(final EntityRef ref, final List<String> properties, final EntityListener callback); }
@Test @TestTarget(ServerVersion.AGM) public void testQueryForStream() throws IOException { handler.addRequest(false, "GET", "/qcbin/rest/domains/domain/projects/project/defects?fields=&query={status[Fixed]}&order-by={}", 200) .responseBody("simply content"); EntityQuery query = new EntityQuery("defect"); query.setValue("status", "Fixed"); query.setPropertyResolved("status", true); String content = IOUtils.toString(entityService.queryForStream(query)); Assert.assertEquals("simply content", content); }
AliRestClient implements RestClient { @Override public String getForString(String template, Object... params) { ByteArrayOutputStream responseBody = new ByteArrayOutputStream(); ResultInfo result = ResultInfo.create(responseBody); get(result, template, params); HttpStatusBasedException.throwForError(result); return responseBody.toString(); } 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 testGetForString() { handler.authenticate(); handler.addRequest("GET", "/qcbin/rest/domains/domain/projects/project/path/arg1/arg2", 200) .responseBody("result"); AliRestClient client = AliRestClient.create(handler.getQcUrl(), "domain", "project", "user", "password", RestClient.SessionStrategy.AUTO_LOGIN); String result = client.getForString("/path/{0}/{1}", "arg1", "arg2"); Assert.assertEquals("result", result); }
EntityService { public void getEntityAsync(EntityRef ref, EntityListener callback) { getEntityAsync(ref, callback, EntityListener.Event.GET); } EntityService(Project project, RestService restService, MetadataService metadataService, ErrorService errorService); void addEntityListener(EntityListener listener); void removeEntityListener(EntityListener listener); void refreshEntity(EntityRef ref); void getEntityAsync(EntityRef ref, EntityListener callback); Entity getEntity(EntityRef ref); EntityList query(EntityQuery query); InputStream queryForStream(EntityQuery query); Entity getDefectLink(int defectId, int linkId); Entity updateEntity(Entity entity, Set<String> fieldsToUpdate, boolean silent); Entity updateEntity(Entity entity, Set<String> fieldsToUpdate, boolean silent, boolean reloadOnFailure); Entity updateEntity(Entity entity, Set<String> fieldsToUpdate, boolean silent, boolean reloadOnFailure, boolean fireUpdate); Entity createEntity(Entity entity, boolean silent); Entity lockEntity(Entity entity, boolean silent); boolean deleteEntity(Entity entity); void unlockEntity(Entity entity); void fireEntityLoaded(final Entity entity, final EntityListener.Event event); void fireEntityNotFound(final EntityRef ref, final boolean removed); void requestCachedEntity(final EntityRef ref, final List<String> properties, final EntityListener callback); }
@Test @TestTarget(ServerVersion.AGM) public void testGetEntityAsync() throws IOException { 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(); entityService.getEntityAsync(new EntityRef("defect", 86), new EntityAdapter() { @Override public void entityLoaded(final Entity entity, final Event event) { handler.done(new Runnable() { @Override public void run() { Assert.assertEquals(86, entity.getId()); Assert.assertEquals(Event.GET, event); } }); } }); handler.consume(); 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(); final EntityRef defect = new EntityRef("defect", 87); entityService.getEntityAsync(defect, new EntityAdapter() { @Override public void entityNotFound(final EntityRef ref, final boolean removed) { handler.done(new Runnable() { @Override public void run() { Assert.assertEquals(defect, ref); Assert.assertFalse(removed); } }); } }); }
EntityService { public void refreshEntity(EntityRef ref) { getEntityAsync(ref, null, EntityListener.Event.REFRESH); } EntityService(Project project, RestService restService, MetadataService metadataService, ErrorService errorService); void addEntityListener(EntityListener listener); void removeEntityListener(EntityListener listener); void refreshEntity(EntityRef ref); void getEntityAsync(EntityRef ref, EntityListener callback); Entity getEntity(EntityRef ref); EntityList query(EntityQuery query); InputStream queryForStream(EntityQuery query); Entity getDefectLink(int defectId, int linkId); Entity updateEntity(Entity entity, Set<String> fieldsToUpdate, boolean silent); Entity updateEntity(Entity entity, Set<String> fieldsToUpdate, boolean silent, boolean reloadOnFailure); Entity updateEntity(Entity entity, Set<String> fieldsToUpdate, boolean silent, boolean reloadOnFailure, boolean fireUpdate); Entity createEntity(Entity entity, boolean silent); Entity lockEntity(Entity entity, boolean silent); boolean deleteEntity(Entity entity); void unlockEntity(Entity entity); void fireEntityLoaded(final Entity entity, final EntityListener.Event event); void fireEntityNotFound(final EntityRef ref, final boolean removed); void requestCachedEntity(final EntityRef ref, final List<String> properties, final EntityListener callback); }
@Test @TestTarget(ServerVersion.AGM) public void refreshEntity() throws IOException { RestInvocations.loadMetadata(handler, "defect"); RestInvocations.loadMetadata(handler, "release-backlog-item"); final EntityRef defect = new EntityRef("defect", 87); addEntityListener(new EntityAdapter() { @Override public void entityLoaded(final Entity entity, final Event event) { handler.done(new Runnable() { @Override public void run() { Assert.assertEquals(86, entity.getId()); Assert.assertEquals(Event.REFRESH, event); } }); } @Override public void entityNotFound(final EntityRef ref, final boolean removed) { handler.done(new Runnable() { @Override public void run() { Assert.assertEquals(defect, ref); Assert.assertFalse(removed); } }); } }); 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(); entityService.refreshEntity(new EntityRef("defect", 86)); handler.consume(); 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(); entityService.refreshEntity(defect); }
EntityService { public Entity getDefectLink(int defectId, int linkId) { if(!restService.getServerStrategy().hasSecondLevelDefectLink()) { EntityQuery linkQuery = new EntityQuery("defect-link"); linkQuery.setValue("id", String.valueOf(linkId)); linkQuery.setPropertyResolved("id", true); return doQuery(linkQuery, true).get(0); } else { return DefectLinkList.create(restService.getForStream("defects/{0}/defect-links/{1}", defectId, linkId), true).get(0); } } EntityService(Project project, RestService restService, MetadataService metadataService, ErrorService errorService); void addEntityListener(EntityListener listener); void removeEntityListener(EntityListener listener); void refreshEntity(EntityRef ref); void getEntityAsync(EntityRef ref, EntityListener callback); Entity getEntity(EntityRef ref); EntityList query(EntityQuery query); InputStream queryForStream(EntityQuery query); Entity getDefectLink(int defectId, int linkId); Entity updateEntity(Entity entity, Set<String> fieldsToUpdate, boolean silent); Entity updateEntity(Entity entity, Set<String> fieldsToUpdate, boolean silent, boolean reloadOnFailure); Entity updateEntity(Entity entity, Set<String> fieldsToUpdate, boolean silent, boolean reloadOnFailure, boolean fireUpdate); Entity createEntity(Entity entity, boolean silent); Entity lockEntity(Entity entity, boolean silent); boolean deleteEntity(Entity entity); void unlockEntity(Entity entity); void fireEntityLoaded(final Entity entity, final EntityListener.Event event); void fireEntityNotFound(final EntityRef ref, final boolean removed); void requestCachedEntity(final EntityRef ref, final List<String> properties, final EntityListener callback); }
@Test @TestTarget(ServerVersion.AGM) public void testGetDefectLink_Apollo() { handler.addRequest(false, "GET", "/qcbin/rest/domains/domain/projects/project/defect-links?fields=&query={id[2763]}&order-by={}", 200) .content("entityServiceTest_defectLink.xml"); Entity link = entityService.getDefectLink(86, 2763); Assert.assertEquals(2763, link.getId()); } @Test @TestTarget(ServerVersion.ALM11) public void testGetDefectLink_Maya() { handler.addRequest(false, "GET", "/qcbin/rest/domains/domain/projects/project/defects/86/defect-links/2763", 200) .content("entityServiceTest_defectLink.xml"); Entity link = entityService.getDefectLink(86, 2763); Assert.assertEquals(2763, link.getId()); }
EntityService { public Entity updateEntity(Entity entity, Set<String> fieldsToUpdate, boolean silent) { return updateEntity(entity, fieldsToUpdate, silent, false, true); } EntityService(Project project, RestService restService, MetadataService metadataService, ErrorService errorService); void addEntityListener(EntityListener listener); void removeEntityListener(EntityListener listener); void refreshEntity(EntityRef ref); void getEntityAsync(EntityRef ref, EntityListener callback); Entity getEntity(EntityRef ref); EntityList query(EntityQuery query); InputStream queryForStream(EntityQuery query); Entity getDefectLink(int defectId, int linkId); Entity updateEntity(Entity entity, Set<String> fieldsToUpdate, boolean silent); Entity updateEntity(Entity entity, Set<String> fieldsToUpdate, boolean silent, boolean reloadOnFailure); Entity updateEntity(Entity entity, Set<String> fieldsToUpdate, boolean silent, boolean reloadOnFailure, boolean fireUpdate); Entity createEntity(Entity entity, boolean silent); Entity lockEntity(Entity entity, boolean silent); boolean deleteEntity(Entity entity); void unlockEntity(Entity entity); void fireEntityLoaded(final Entity entity, final EntityListener.Event event); void fireEntityNotFound(final EntityRef ref, final boolean removed); void requestCachedEntity(final EntityRef ref, final List<String> properties, final EntityListener callback); }
@Test @TestTarget(ServerVersion.AGM) public void testUpdateEntity() { handler.addRequest(false, "PUT", "/qcbin/rest/domains/domain/projects/project/defects/86", 200) .expectXmlBody("<Entity Type=\"defect\"><Fields><Field Name=\"status\"><Value>Closed</Value></Field></Fields></Entity>") .content("entityServiceTest_entity.xml"); handler.async(); addEntityListener(new EntityLoaded(handler, "defect", 86, EntityListener.Event.GET)); Entity defect = new Entity("defect", 86); defect.setProperty("priority", "1-Critical"); defect.setProperty("status", "Closed"); Entity updated = entityService.updateEntity(defect, Collections.singleton("status"), true, false, true); Assert.assertEquals(86, updated.getId()); } @Test @TestTarget(ServerVersion.AGM) public void testUpdateEntity_failure() { handler.addRequest(false, "PUT", "/qcbin/rest/domains/domain/projects/project/defects/86", 500) .responseBody("Failed"); Entity defect = new Entity("defect", 86); Entity updated = entityService.updateEntity(defect, Collections.singleton("status"), false, false, true); Assert.assertNull(updated); checkError("Failed"); } @Test @TestTarget(ServerVersion.AGM) public void testUpdateEntity_silentFailure() { handler.addRequest(false, "PUT", "/qcbin/rest/domains/domain/projects/project/defects/86", 500) .responseBody("Failed"); Entity defect = new Entity("defect", 86); Entity updated = entityService.updateEntity(defect, Collections.singleton("status"), true, false, true); Assert.assertNull(updated); } @Test @TestTarget(ServerVersion.AGM) public void testUpdateEntity_silentReload() { handler.addRequest(false, "PUT", "/qcbin/rest/domains/domain/projects/project/defects/86", 500) .responseBody("Failed"); 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"); Entity defect = new Entity("defect", 86); Entity updated = entityService.updateEntity(defect, Collections.singleton("status"), true, true, false); Assert.assertEquals(86, updated.getId()); } @Test @TestTarget(ServerVersion.AGM) public void testUpdateEntity_silentReloadFailure() { handler.addRequest(false, "PUT", "/qcbin/rest/domains/domain/projects/project/defects/86", 500) .responseBody("Failed"); 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={}", 500) .responseBody("Failed again"); Entity defect = new Entity("defect", 86); Entity updated = entityService.updateEntity(defect, Collections.singleton("status"), false, true, false); Assert.assertNull(updated); checkError("Failed"); } @Test @TestTarget(ServerVersion.ALM11) public void testUpdateEntity_MayaLink_failure() { handler.addRequest(false, "PUT", "/qcbin/rest/domains/domain/projects/project/defects/86/defect-links/2763", 500) .responseBody("Failed"); Entity link = new Entity("defect-link", 2763); link.setProperty("first-endpoint-id", "86"); Entity updated = entityService.updateEntity(link, Collections.singleton("comment"), false, false, false); Assert.assertNull(updated); checkError("Failed"); } @Test @TestTarget(ServerVersion.ALM11) public void testUpdateEntity_MayaLink_silentFailure() { handler.addRequest(false, "PUT", "/qcbin/rest/domains/domain/projects/project/defects/86/defect-links/2763", 500) .responseBody("Failed"); Entity link = new Entity("defect-link", 2763); link.setProperty("first-endpoint-id", "86"); Entity updated = entityService.updateEntity(link, Collections.singleton("comment"), true, false, false); Assert.assertNull(updated); }
AliRestClient implements RestClient { @Override public InputStream getForStream(String template, Object... params) { ByteArrayOutputStream responseBody = new ByteArrayOutputStream(); ResultInfo result = ResultInfo.create(responseBody); get(result, template, params); HttpStatusBasedException.throwForError(result); return new ByteArrayInputStream(responseBody.toByteArray()); } 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 testGetForStream() throws IOException { handler.authenticate(); handler.addRequest("GET", "/qcbin/rest/domains/domain/projects/project/path/arg1/arg2", 200) .responseBody("result"); AliRestClient client = AliRestClient.create(handler.getQcUrl(), "domain", "project", "user", "password", RestClient.SessionStrategy.AUTO_LOGIN); InputStream result = client.getForStream("/path/{0}/{1}", "arg1", "arg2"); Assert.assertEquals("result", IOUtils.toString(result)); }
EntityService { public Entity createEntity(Entity entity, boolean silent) { if("defect-link".equals(entity.getType()) && restService.getServerStrategy().hasSecondLevelDefectLink()) { return createOldDefectLink(entity, silent); } String xml = XMLOutputterFactory.getXMLOutputter().outputString(new Document(entity.toElement(null))); MyResultInfo result = new MyResultInfo(); if(restService.post(xml, result, "{0}s", entity.getType()) != HttpStatus.SC_CREATED) { if(!silent) { errorService.showException(new RestException(result)); } return null; } else { return parseEntityAndFireEvent(result.getBodyAsStream(), EntityListener.Event.CREATE); } } EntityService(Project project, RestService restService, MetadataService metadataService, ErrorService errorService); void addEntityListener(EntityListener listener); void removeEntityListener(EntityListener listener); void refreshEntity(EntityRef ref); void getEntityAsync(EntityRef ref, EntityListener callback); Entity getEntity(EntityRef ref); EntityList query(EntityQuery query); InputStream queryForStream(EntityQuery query); Entity getDefectLink(int defectId, int linkId); Entity updateEntity(Entity entity, Set<String> fieldsToUpdate, boolean silent); Entity updateEntity(Entity entity, Set<String> fieldsToUpdate, boolean silent, boolean reloadOnFailure); Entity updateEntity(Entity entity, Set<String> fieldsToUpdate, boolean silent, boolean reloadOnFailure, boolean fireUpdate); Entity createEntity(Entity entity, boolean silent); Entity lockEntity(Entity entity, boolean silent); boolean deleteEntity(Entity entity); void unlockEntity(Entity entity); void fireEntityLoaded(final Entity entity, final EntityListener.Event event); void fireEntityNotFound(final EntityRef ref, final boolean removed); void requestCachedEntity(final EntityRef ref, final List<String> properties, final EntityListener callback); }
@Test @TestTarget(ServerVersion.AGM) public void testCreateEntity() { handler.addRequest(false, "POST", "/qcbin/rest/domains/domain/projects/project/defects", 201) .expectXmlBody("<Entity Type=\"defect\"><Fields><Field Name=\"status\"><Value>New</Value></Field></Fields></Entity>") .content("entityServiceTest_entity.xml"); handler.async(); addEntityListener(new EntityLoaded(handler, "defect", 86, EntityListener.Event.CREATE)); Entity defect = new Entity("defect"); defect.setProperty("status", "New"); Entity created = entityService.createEntity(defect, false); Assert.assertEquals(86, created.getId()); } @Test @TestTarget(ServerVersion.AGM) public void testCreateEntity_failure() { handler.addRequest(false, "POST", "/qcbin/rest/domains/domain/projects/project/defects", 500) .responseBody("Failed"); Entity defect = new Entity("defect"); Entity created = entityService.createEntity(defect, false); Assert.assertNull(created); checkError("Failed"); } @Test @TestTarget(ServerVersion.AGM) public void testCreateEntity_silentFailure() { handler.addRequest(false, "POST", "/qcbin/rest/domains/domain/projects/project/defects", 500) .responseBody("Failed"); Entity defect = new Entity("defect"); Entity created = entityService.createEntity(defect, true); Assert.assertNull(created); } @Test @TestTarget(ServerVersion.ALM11) public void testCreateEntity_MayaLink_failure() { handler.addRequest(false, "POST", "/qcbin/rest/domains/domain/projects/project/defects/86/defect-links", 500) .responseBody("Failed"); Entity link = new Entity("defect-link"); link.setProperty("first-endpoint-id", "86"); Entity created = entityService.createEntity(link, false); Assert.assertNull(created); checkError("Failed"); } @Test @TestTarget(ServerVersion.ALM11) public void testCreateEntity_MayaLink_silentFailure() { handler.addRequest(false, "POST", "/qcbin/rest/domains/domain/projects/project/defects/86/defect-links", 500) .responseBody("Failed"); Entity link = new Entity("defect-link"); link.setProperty("first-endpoint-id", "86"); Entity created = entityService.createEntity(link, true); Assert.assertNull(created); }
EntityService { public Entity lockEntity(Entity entity, boolean silent) { Entity locked = doLock(new EntityRef(entity), silent); if(locked != null) { if(!locked.matches(entity)) { if(!silent) { Messages.showDialog("Item has been recently modified on the server. Local values have been updated to match the up-to-date revision.", "Entity Update", new String[]{"Continue"}, 0, Messages.getInformationIcon()); } fireEntityLoaded(locked, EntityListener.Event.GET); } } return locked; } EntityService(Project project, RestService restService, MetadataService metadataService, ErrorService errorService); void addEntityListener(EntityListener listener); void removeEntityListener(EntityListener listener); void refreshEntity(EntityRef ref); void getEntityAsync(EntityRef ref, EntityListener callback); Entity getEntity(EntityRef ref); EntityList query(EntityQuery query); InputStream queryForStream(EntityQuery query); Entity getDefectLink(int defectId, int linkId); Entity updateEntity(Entity entity, Set<String> fieldsToUpdate, boolean silent); Entity updateEntity(Entity entity, Set<String> fieldsToUpdate, boolean silent, boolean reloadOnFailure); Entity updateEntity(Entity entity, Set<String> fieldsToUpdate, boolean silent, boolean reloadOnFailure, boolean fireUpdate); Entity createEntity(Entity entity, boolean silent); Entity lockEntity(Entity entity, boolean silent); boolean deleteEntity(Entity entity); void unlockEntity(Entity entity); void fireEntityLoaded(final Entity entity, final EntityListener.Event event); void fireEntityNotFound(final EntityRef ref, final boolean removed); void requestCachedEntity(final EntityRef ref, final List<String> properties, final EntityListener callback); }
@Test @TestTarget(ServerVersion.ALM11) public void testLockEntity() { handler.addRequest(false, "POST", "/qcbin/rest/domains/domain/projects/project/defects/86/lock", 200) .content("entityServiceTest_entity.xml"); Entity defect = new Entity("defect", 86); Entity entity = entityService.lockEntity(defect, false); Assert.assertEquals(86, entity.getId()); } @Test @TestTarget(ServerVersion.ALM11) public void testLockEntity_failure() { handler.addRequest(false, "POST", "/qcbin/rest/domains/domain/projects/project/defects/86/lock", 500) .responseBody("Failed"); Entity defect = new Entity("defect", 86); Entity entity = entityService.lockEntity(defect, false); Assert.assertNull(entity); checkError("Failed"); } @Test @TestTarget(ServerVersion.ALM11) public void testLockEntity_silentFailure() { handler.addRequest(false, "POST", "/qcbin/rest/domains/domain/projects/project/defects/86/lock", 500) .responseBody("Failed"); Entity defect = new Entity("defect", 86); Entity entity = entityService.lockEntity(defect, true); Assert.assertNull(entity); }
EntityService { public boolean deleteEntity(Entity entity) { if("defect-link".equals(entity.getType()) && restService.getServerStrategy().hasSecondLevelDefectLink()) { return deleteOldDefectLink(entity); } MyResultInfo result = new MyResultInfo(); if(restService.delete(result, "{0}s/{1}", entity.getType(), entity.getId()) != HttpStatus.SC_OK) { errorService.showException(new RestException(result)); return false; } else { fireEntityNotFound(new EntityRef(entity), true); return true; } } EntityService(Project project, RestService restService, MetadataService metadataService, ErrorService errorService); void addEntityListener(EntityListener listener); void removeEntityListener(EntityListener listener); void refreshEntity(EntityRef ref); void getEntityAsync(EntityRef ref, EntityListener callback); Entity getEntity(EntityRef ref); EntityList query(EntityQuery query); InputStream queryForStream(EntityQuery query); Entity getDefectLink(int defectId, int linkId); Entity updateEntity(Entity entity, Set<String> fieldsToUpdate, boolean silent); Entity updateEntity(Entity entity, Set<String> fieldsToUpdate, boolean silent, boolean reloadOnFailure); Entity updateEntity(Entity entity, Set<String> fieldsToUpdate, boolean silent, boolean reloadOnFailure, boolean fireUpdate); Entity createEntity(Entity entity, boolean silent); Entity lockEntity(Entity entity, boolean silent); boolean deleteEntity(Entity entity); void unlockEntity(Entity entity); void fireEntityLoaded(final Entity entity, final EntityListener.Event event); void fireEntityNotFound(final EntityRef ref, final boolean removed); void requestCachedEntity(final EntityRef ref, final List<String> properties, final EntityListener callback); }
@Test @TestTarget(ServerVersion.AGM) public void testDeleteEntity() { handler.addRequest(false, "DELETE", "/qcbin/rest/domains/domain/projects/project/defects/86", 200); handler.async(); addEntityListener(new EntityNotFound(handler, "defect", 86, true)); Entity defect = new Entity("defect", 86); boolean deleted = entityService.deleteEntity(defect); Assert.assertTrue(deleted); } @Test @TestTarget(ServerVersion.AGM) public void testDeleteEntity_failure() { handler.addRequest(false, "DELETE", "/qcbin/rest/domains/domain/projects/project/defects/86", 500) .responseBody("Failed"); Entity defect = new Entity("defect", 86); boolean deleted = entityService.deleteEntity(defect); Assert.assertFalse(deleted); checkError("Failed"); } @Test @TestTarget(ServerVersion.ALM11) public void testDeleteEntity_MayaLink_failure() { handler.addRequest(false, "DELETE", "/qcbin/rest/domains/domain/projects/project/defects/86/defect-links/2763", 500) .responseBody("Failed"); Entity link = new Entity("defect-link", 2763); link.setProperty("first-endpoint-id", "86"); boolean deleted = entityService.deleteEntity(link); Assert.assertFalse(deleted); checkError("Failed"); }
AliRestClient implements RestClient { @Override public int get(ResultInfo result, String template, Object... params) { GetMethod method = createMethod(domain, project, GET_BUILDER, null, template, params); executeHttpMethod(method, 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 testGet() { handler.authenticate(); handler.addRequest("GET", "/qcbin/rest/domains/domain/projects/project/path/arg1/arg2", 200) .responseHeader("custom", "value") .responseBody("result"); AliRestClient client = AliRestClient.create(handler.getQcUrl(), "domain", "project", "user", "password", RestClient.SessionStrategy.AUTO_LOGIN); ResultInfo resultInfo = ResultInfo.create(new ByteArrayOutputStream()); int code = client.get(resultInfo, "/path/{0}/{1}", "arg1", "arg2"); Assert.assertEquals(200, code); Assert.assertEquals("result", resultInfo.getBodyStream().toString()); Assert.assertEquals("value", resultInfo.getHeaders().get("custom")); }
EntityService { public void unlockEntity(Entity entity) { restService.delete("{0}s/{1}/lock", entity.getType(), String.valueOf(entity.getId())); } EntityService(Project project, RestService restService, MetadataService metadataService, ErrorService errorService); void addEntityListener(EntityListener listener); void removeEntityListener(EntityListener listener); void refreshEntity(EntityRef ref); void getEntityAsync(EntityRef ref, EntityListener callback); Entity getEntity(EntityRef ref); EntityList query(EntityQuery query); InputStream queryForStream(EntityQuery query); Entity getDefectLink(int defectId, int linkId); Entity updateEntity(Entity entity, Set<String> fieldsToUpdate, boolean silent); Entity updateEntity(Entity entity, Set<String> fieldsToUpdate, boolean silent, boolean reloadOnFailure); Entity updateEntity(Entity entity, Set<String> fieldsToUpdate, boolean silent, boolean reloadOnFailure, boolean fireUpdate); Entity createEntity(Entity entity, boolean silent); Entity lockEntity(Entity entity, boolean silent); boolean deleteEntity(Entity entity); void unlockEntity(Entity entity); void fireEntityLoaded(final Entity entity, final EntityListener.Event event); void fireEntityNotFound(final EntityRef ref, final boolean removed); void requestCachedEntity(final EntityRef ref, final List<String> properties, final EntityListener callback); }
@Test @TestTarget(ServerVersion.ALM11) public void testUnlockEntity() { handler.addRequest(false, "DELETE", "/qcbin/rest/domains/domain/projects/project/defects/86/lock", 200); Entity defect = new Entity("defect", 86); entityService.unlockEntity(defect); }
EntityService { public void requestCachedEntity(final EntityRef ref, final List<String> properties, final EntityListener callback) { ApplicationUtil.executeOnPooledThread(new Runnable() { public void run() { final LinkedList<Entity> done = new LinkedList<Entity>(); listeners.fire(new WeakListeners.Action<EntityListener>() { public void fire(EntityListener listener) { if(done.isEmpty() && listener instanceof CachingEntityListener) { Entity cached = ((CachingEntityListener) listener).lookup(ref); if(cached != null) { for(String property: properties) { if(!cached.isInitialized(property)) { return; } } done.add(cached); } } } }); if(done.isEmpty()) { getEntityAsync(ref, callback); } else { callback.entityLoaded(done.getFirst(), EntityListener.Event.CACHE); } } }); } EntityService(Project project, RestService restService, MetadataService metadataService, ErrorService errorService); void addEntityListener(EntityListener listener); void removeEntityListener(EntityListener listener); void refreshEntity(EntityRef ref); void getEntityAsync(EntityRef ref, EntityListener callback); Entity getEntity(EntityRef ref); EntityList query(EntityQuery query); InputStream queryForStream(EntityQuery query); Entity getDefectLink(int defectId, int linkId); Entity updateEntity(Entity entity, Set<String> fieldsToUpdate, boolean silent); Entity updateEntity(Entity entity, Set<String> fieldsToUpdate, boolean silent, boolean reloadOnFailure); Entity updateEntity(Entity entity, Set<String> fieldsToUpdate, boolean silent, boolean reloadOnFailure, boolean fireUpdate); Entity createEntity(Entity entity, boolean silent); Entity lockEntity(Entity entity, boolean silent); boolean deleteEntity(Entity entity); void unlockEntity(Entity entity); void fireEntityLoaded(final Entity entity, final EntityListener.Event event); void fireEntityNotFound(final EntityRef ref, final boolean removed); void requestCachedEntity(final EntityRef ref, final List<String> properties, final EntityListener callback); }
@Test @TestTarget(ServerVersion.AGM) public void testRequestCachedEntity() { EntityRef ref = new EntityRef("defect", 86); Entity entity = new Entity(ref.type, ref.id); entity.setProperty("status", "New"); addEntityListener(new Cache(ref, entity)); handler.async(); entityService.requestCachedEntity(ref, Arrays.asList("status"), new EntityLoaded(handler, "defect", 86, EntityListener.Event.CACHE, new EntityLoaded.Listener() { @Override public void evaluate(Entity entity, EntityListener.Event event) { Assert.assertEquals("New", entity.getPropertyValue("status")); } })); }
MetadataService extends AbstractCachingService<String, Metadata, AbstractCachingService.Callback<Metadata>> { public Metadata getEntityMetadata(String entityName) { return getValue(entityName); } MetadataService(Project project, MetadataSimpleService metadataService, RestService restService); Metadata getEntityMetadata(String entityName); void loadEntityMetadataAsync(String entityName, MetadataCallback callback); Metadata getCachedEntityMetadata(String entityType); Exception getCachedFailure(String entityType); }
@Test public void testGetEntityMetadata() throws IOException { requests(); Metadata metadata = metadataService.getEntityMetadata("defect"); Assert.assertEquals("defect", metadata.getEntityType()); Assert.assertEquals(Integer.class, metadata.getField("id").getClazz()); Assert.assertEquals(metadata, metadataService.getEntityMetadata("defect")); }
MetadataService extends AbstractCachingService<String, Metadata, AbstractCachingService.Callback<Metadata>> { public Metadata getCachedEntityMetadata(String entityType) { return getCachedValue(entityType); } MetadataService(Project project, MetadataSimpleService metadataService, RestService restService); Metadata getEntityMetadata(String entityName); void loadEntityMetadataAsync(String entityName, MetadataCallback callback); Metadata getCachedEntityMetadata(String entityType); Exception getCachedFailure(String entityType); }
@Test public void testGetCachedEntityMetadata() throws IOException { requests(); Metadata metadata = metadataService.getCachedEntityMetadata("defect"); Assert.assertNull(metadata); metadataService.getEntityMetadata("defect"); metadata = metadataService.getCachedEntityMetadata("defect"); Assert.assertEquals("defect", metadata.getEntityType()); Assert.assertEquals(Integer.class, metadata.getField("id").getClazz()); Assert.assertEquals(metadata, metadataService.getEntityMetadata("defect")); }
MetadataService extends AbstractCachingService<String, Metadata, AbstractCachingService.Callback<Metadata>> { public Exception getCachedFailure(String entityType) { return super.getCachedFailure(entityType); } MetadataService(Project project, MetadataSimpleService metadataService, RestService restService); Metadata getEntityMetadata(String entityName); void loadEntityMetadataAsync(String entityName, MetadataCallback callback); Metadata getCachedEntityMetadata(String entityType); Exception getCachedFailure(String entityType); }
@Test public void testGetCachedFailure() throws IOException { handler.addRequest(false, "GET", "/qcbin/rest/domains/domain/projects/project/customization/entities/non-existing-type/fields", 404); try { metadataService.getEntityMetadata("non-existing-type"); Assert.fail("should have failed"); } catch (Exception e) { } try { metadataService.getEntityMetadata("non-existing-type"); Assert.fail("should have failed"); } catch (Exception e) { } }
MetadataService extends AbstractCachingService<String, Metadata, AbstractCachingService.Callback<Metadata>> { public void loadEntityMetadataAsync(String entityName, MetadataCallback callback) { getValueAsync(entityName, Proxy.create(callback)); } MetadataService(Project project, MetadataSimpleService metadataService, RestService restService); Metadata getEntityMetadata(String entityName); void loadEntityMetadataAsync(String entityName, MetadataCallback callback); Metadata getCachedEntityMetadata(String entityType); Exception getCachedFailure(String entityType); }
@Test public void testLoadEntityMetadataAsync() throws InterruptedException, IOException { requests(); handler.async(); metadataService.loadEntityMetadataAsync("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, metadataService.getEntityMetadata("defect")); final Thread t = Thread.currentThread(); metadataService.loadEntityMetadataAsync("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() { handler.fail("Should have succeeded"); } }); } @Test public void testLoadEntityMetadataAsync_failure() throws InterruptedException, IOException { handler.addRequest(false, "GET", "/qcbin/rest/domains/domain/projects/project/customization/entities/non-existing-type/fields", 404); handler.async(); metadataService.loadEntityMetadataAsync("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(); } }); }
AliRestClient implements RestClient { @Override public int post(InputData data, ResultInfo result, String template, Object... params) { PostMethod postMethod = createMethod(domain, project, POST_BUILDER, createRequestEntity(data), template, params); setHeaders(postMethod, data.getHeaders()); executeHttpMethod(postMethod, 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 testPost() { handler.authenticate(); handler.addRequest("POST", "/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.post(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")); }
LoginController { public String login(UserForm userForm) { log.debug("LoginController.login {}", userForm); try { if (userForm == null) { return "ERROR"; } else if (loginService.login(userForm)) { return "OK"; } else { return "KO"; } } catch (Exception e) { return "ERROR"; } } String login(UserForm userForm); void logout(UserForm userForm); public LoginService loginService; }
@Test public void testLogin() { loginController.login(userForm); verify(loginService).login(userForm); verifyNoMoreInteractions(loginService); } @Test public void testLoginOk() { when(loginService.login(userForm)).thenReturn(true); assertEquals("OK", loginController.login(userForm)); verify(loginService).login(userForm); verifyNoMoreInteractions(loginService); } @Test public void testLoginKo() { when(loginService.login(userForm)).thenReturn(false); assertEquals("KO", loginController.login(userForm)); } @Test public void testLoginError() { assertEquals("ERROR", loginController.login(null)); } @Test public void testLoginWithException() { when(loginService.login(userForm)) .thenThrow(IllegalArgumentException.class); assertEquals("ERROR", loginController.login(userForm)); }
LoginService { public boolean login(UserForm userForm) { log.debug("LoginService.login {}", userForm); checkForm(userForm); String username = userForm.getUsername(); if (usersLogged.contains(username)) { throw new LoginException(username + " already logged"); } boolean login = loginRepository.login(userForm); if (login) { usersLogged.add(username); } return login; } boolean login(UserForm userForm); void logout(UserForm userForm); int getUserLoggedCount(); }
@Test void testLoginKo() { when(loginRepository.login(any(UserForm.class))).thenReturn(false); assertFalse(loginService.login(userForm)); verify(loginRepository, times(1)).login(userForm); } @Test void testLoginTwice() { when(loginRepository.login(userForm)).thenReturn(true); assertThrows(LoginException.class, () -> { loginService.login(userForm); loginService.login(userForm); }); } @Test public void testServiceLoginOk() { when(loginRepository.login(any(UserForm.class))).thenReturn(true); assertTrue(loginService.login(userForm)); verify(loginRepository, atLeast(1)).login(userForm); verifyNoMoreInteractions(loginRepository); } @Test public void testServiceLoginBad() { when(loginRepository.login(any(UserForm.class))).thenReturn(false); assertFalse(loginService.login(userForm)); verify(loginRepository, times(1)).login(userForm); verifyNoMoreInteractions(loginRepository); } @Test(expected = LoginException.class) public void testServiceLoginTwice() { when(loginRepository.login(userForm)).thenReturn(true); loginService.login(userForm); loginService.login(userForm); } @Test void testLoginOk() { when(loginRepository.login(any(UserForm.class))).thenReturn(true); assertTrue(loginService.login(userForm)); verify(loginRepository, atLeast(1)).login(userForm); }
LoginController { public void logout(UserForm userForm) { log.debug("LoginController.logout {}", userForm); loginService.logout(userForm); } String login(UserForm userForm); void logout(UserForm userForm); public LoginService loginService; }
@Test public void testLogout() { loginController.logout(userForm); verify(loginService).logout(userForm); verifyNoMoreInteractions(loginService); }
JSON { public static Object parse(String json) throws ParseException { StringReader reader = new StringReader(json); try{ return parse(reader); } catch(IOException e){ throw new ParseException(e.getMessage()); } finally{ reader.close(); } } private JSON(); static String json(Object obj); static void json(Object obj, Writer writer); static void json(Object obj, Writer writer, boolean writeClass); static String json(Object obj, String[] properties); static void json(Object obj, final String[] properties, Writer writer); static void json(Object obj, final String[] properties, Writer writer, boolean writeClass); static Object parse(String json); static Object parse(Reader reader); static T parse(String json, Class<T> type); @SuppressWarnings("unchecked") static T parse(Reader reader, Class<T> type); static Object[] parse(String json, Class<?>[] types); static Object[] parse(Reader reader, Class<?>[] types); static Object parse(String json, JSONVisitor handler); static Object parse(Reader reader, JSONVisitor handler); static final char LBRACE; static final char LSQUARE; static final char COMMA; static final String NULL; static final byte END; }
@Test public void testParse2JSONObject() throws Exception { JSONObject jo = (JSONObject)JSON.parse("{name:'qianlei',array:[1,2,3,4,98.123],b1:TRUE,$1:NULL,$2:FALSE,__3:NULL}"); assertEquals(jo.getString("name"), "qianlei"); assertEquals(jo.getArray("array").length(), 5); assertEquals(jo.get("$2"), Boolean.FALSE); assertEquals(jo.get("__3"), null); for(int i=0;i<10000;i++) JSON.parse("{\"name\":\"qianlei\",\"array\":[1,2,3,4,98.123],\"displayName\":\"钱磊\"}"); long now = System.currentTimeMillis(); for(int i=0;i<10000;i++) JSON.parse("{\"name\":\"qianlei\",\"array\":[1,2,3,4,98.123],\"displayName\":\"钱磊\"}"); System.out.println("parse to JSONObject 10000 times in: " + ( System.currentTimeMillis()-now) ); } @Test @SuppressWarnings("unchecked") public void testParse2Class() throws Exception { int[] o1 = {1,2,3,4,5}, o2 = JSON.parse("[1.2,2,3,4,5]", int[].class); assertEquals(o2.length, 5); for(int i=0;i<5;i++) assertEquals(o1[i], o2[i]); List l1 = (List)JSON.parse("[1.2,2,3,4,5]", List.class); assertEquals(l1.size(), 5); for(int i=0;i<5;i++) assertEquals(o1[i], ((Number) l1.get(i)).intValue()); Bean bean = JSON.parse("{name:'qianlei',array:[1,2,3,4,98.123],displayName:'钱磊',$$:214726,$b:TRUE}", Bean.class); assertEquals(bean.getName(), "qianlei"); assertEquals(bean.getDisplayName(), "钱磊"); assertEquals(bean.array.length, 5); assertEquals(bean.$$, 214726); assertEquals(bean.$b, true); for(int i=0;i<10000;i++) JSON.parse("{name:'qianlei',array:[1,2,3,4,98.123],displayName:'钱磊'}", Bean1.class); long now = System.currentTimeMillis(); for(int i=0;i<10000;i++) JSON.parse("{name:'qianlei',array:[1,2,3,4,98.123],displayName:'钱磊'}", Bean1.class); System.out.println("parse to Class 10000 times in: " + ( System.currentTimeMillis()-now) ); } @Test public void testParse2Arguments() throws Exception { Object[] test = JSON.parse("[1.2, 2, {name:'qianlei',array:[1,2,3,4,98.123]} ]", new Class<?>[]{ int.class, int.class, Bean.class }); assertEquals(test[1], 2); assertEquals(test[2].getClass(), Bean.class); test = JSON.parse("[1.2, 2]", new Class<?>[]{ int.class, int.class }); assertEquals(test[0], 1); }
URL implements Serializable { public String getPath() { return path; } protected URL(); URL(String protocol, String host, int port); URL(String protocol, String host, int port, String[] pairs); URL(String protocol, String host, int port, Map<String, String> parameters); URL(String protocol, String host, int port, String path); URL(String protocol, String host, int port, String path, String... pairs); URL(String protocol, String host, int port, String path, Map<String, String> parameters); URL(String protocol, String username, String password, String host, int port, String path); URL(String protocol, String username, String password, String host, int port, String path, String... pairs); URL(String protocol, String username, String password, String host, int port, String path, Map<String, String> parameters); static URL valueOf(String url); String getProtocol(); String getUsername(); String getPassword(); String getAuthority(); String getHost(); String getIp(); int getPort(); int getPort(int defaultPort); String getAddress(); String getBackupAddress(); String getBackupAddress(int defaultPort); List<URL> getBackupUrls(); String getPath(); String getAbsolutePath(); URL setProtocol(String protocol); URL setUsername(String username); URL setPassword(String password); URL setAddress(String address); URL setHost(String host); URL setPort(int port); URL setPath(String path); Map<String, String> getParameters(); String getParameterAndDecoded(String key); String getParameterAndDecoded(String key, String defaultValue); String getParameter(String key); String getParameter(String key, String defaultValue); String[] getParameter(String key, String[] defaultValue); URL getUrlParameter(String key); double getParameter(String key, double defaultValue); float getParameter(String key, float defaultValue); long getParameter(String key, long defaultValue); int getParameter(String key, int defaultValue); short getParameter(String key, short defaultValue); byte getParameter(String key, byte defaultValue); float getPositiveParameter(String key, float defaultValue); double getPositiveParameter(String key, double defaultValue); long getPositiveParameter(String key, long defaultValue); int getPositiveParameter(String key, int defaultValue); short getPositiveParameter(String key, short defaultValue); byte getPositiveParameter(String key, byte defaultValue); char getParameter(String key, char defaultValue); boolean getParameter(String key, boolean defaultValue); boolean hasParameter(String key); String getMethodParameterAndDecoded(String method, String key); String getMethodParameterAndDecoded(String method, String key, String defaultValue); String getMethodParameter(String method, String key); String getMethodParameter(String method, String key, String defaultValue); double getMethodParameter(String method, String key, double defaultValue); float getMethodParameter(String method, String key, float defaultValue); long getMethodParameter(String method, String key, long defaultValue); int getMethodParameter(String method, String key, int defaultValue); short getMethodParameter(String method, String key, short defaultValue); byte getMethodParameter(String method, String key, byte defaultValue); double getMethodPositiveParameter(String method, String key, double defaultValue); float getMethodPositiveParameter(String method, String key, float defaultValue); long getMethodPositiveParameter(String method, String key, long defaultValue); int getMethodPositiveParameter(String method, String key, int defaultValue); short getMethodPositiveParameter(String method, String key, short defaultValue); byte getMethodPositiveParameter(String method, String key, byte defaultValue); char getMethodParameter(String method, String key, char defaultValue); boolean getMethodParameter(String method, String key, boolean defaultValue); boolean hasMethodParameter(String method, String key); boolean isLocalHost(); boolean isAnyHost(); URL addParameterAndEncoded(String key, String value); URL addParameter(String key, boolean value); URL addParameter(String key, char value); URL addParameter(String key, byte value); URL addParameter(String key, short value); URL addParameter(String key, int value); URL addParameter(String key, long value); URL addParameter(String key, float value); URL addParameter(String key, double value); URL addParameter(String key, Enum<?> value); URL addParameter(String key, Number value); URL addParameter(String key, CharSequence value); URL addParameter(String key, String value); URL addParameterIfAbsent(String key, String value); URL addParameters(Map<String, String> parameters); URL addParametersIfAbsent(Map<String, String> parameters); URL addParameters(String... pairs); URL addParameterString(String query); URL removeParameter(String key); URL removeParameters(Collection<String> keys); URL removeParameters(String... keys); URL clearParameters(); String getRawParameter(String key); Map<String, String> toMap(); String toString(); String toString(String... parameters); String toIdentityString(); String toIdentityString(String... parameters); String toFullString(); String toFullString(String... parameters); String toParameterString(); String toParameterString(String... parameters); java.net.URL toJavaURL(); InetSocketAddress toInetSocketAddress(); String getServiceKey(); String toServiceString(); @Deprecated String getServiceName(); String getServiceInterface(); URL setServiceInterface(String service); @Deprecated int getIntParameter(String key); @Deprecated int getIntParameter(String key, int defaultValue); @Deprecated int getPositiveIntParameter(String key, int defaultValue); @Deprecated boolean getBooleanParameter(String key); @Deprecated boolean getBooleanParameter(String key, boolean defaultValue); @Deprecated int getMethodIntParameter(String method, String key); @Deprecated int getMethodIntParameter(String method, String key, int defaultValue); @Deprecated int getMethodPositiveIntParameter(String method, String key, int defaultValue); @Deprecated boolean getMethodBooleanParameter(String method, String key); @Deprecated boolean getMethodBooleanParameter(String method, String key, boolean defaultValue); static String encode(String value); static String decode(String value); @Override int hashCode(); @Override boolean equals(Object obj); }
@Test public void test_Path() throws Exception { URL url = new URL("dubbo", "localhost", 20880, " assertEquals("path", url.getPath()); }
CopyTask implements Task { @Override public void execute(final TaskContext context) throws TaskException { try { final URL resource = findJsDocArchive(); copyTo(resource, context.getTempDir(), "jsdoc.zip"); } catch (IOException e) { throw new TaskException("Unable to copy jsdoc zip to temp dir.", e); } } @Override void execute(final TaskContext context); }
@Test public void testCopyDirDoesntExist() { final File tempFile = new File(temporaryFolder.getRoot(), "rooty"); final TaskContext context = new TaskContext(null, null, null, null, null, null, tempFile, false, true, false, true, null); copyTask.execute(context); Assert.assertTrue("jsdoc.zip should exist.", new File(tempFile, "jsdoc.zip").exists()); } @Test public void testCopyDirExists() { final File tempFile = new File(temporaryFolder.getRoot(), "rooty"); tempFile.mkdirs(); final TaskContext context = new TaskContext(null, null, null, null, null, null, tempFile, false, true, false, false, null); copyTask.execute(context); Assert.assertTrue("jsdoc.zip should exist.", new File(tempFile, "jsdoc.zip").exists()); } @Test public void testCopyFileSize() { final File tempFile = new File(temporaryFolder.getRoot(), "rooty"); final TaskContext context = new TaskContext(null, null, null, null, null, null, tempFile, false, true, false, true, null); copyTask.execute(context); Assert.assertTrue("jsdoc.zip should exist.", new File(tempFile, "jsdoc.zip").exists()); final long size = FileUtils.sizeOfDirectory(tempFile); Assert.assertTrue("should be big.", size > 400000); }
JsDocArgumentBuilder { public List<String> build(TaskContext context) { final List<String> arguments = new ArrayList<String>(); final File basePath = context.getJsDocDir(); arguments.add("java"); arguments.add("-classpath"); arguments.add(replace(new File(basePath, "rhino" + File.separator + "js.jar").toString())); arguments.add("org.mozilla.javascript.tools.shell.Main"); for (final String module : MODULES) { arguments.add("-modules"); arguments.add(asUriString(new File(basePath, module))); } arguments.add(replace(new File(basePath, "jsdoc.js").toString())); if (context.isRecursive()) { arguments.add("-r"); } if (context.isLenient()) { arguments.add("-l"); } if (context.getConfigFile() != null) { arguments.add("-c"); arguments.add(context.getConfigFile().toString()); } if (context.isIncludePrivate()) { arguments.add("-p"); } if (context.getTutorialsDirectory() != null) { arguments.add("-u"); arguments.add(context.getTutorialsDirectory().toString()); } if (context.getTemplateDirectory() != null) { arguments.add("-t"); arguments.add(context.getTemplateDirectory().toString()); } arguments.add("-d"); arguments.add(context.getOutputDir().toString()); for (final File sourceFile : context.getSourceDir()) { arguments.add(sourceFile.toString()); } return arguments; } List<String> build(TaskContext context); }
@Test public void testContextWithTemplate() { TaskContext.Builder configBuilder = new TaskContext.Builder(minimumBuilder) .withTemplateDirectory(new File("foo/bar")); Assert.assertTrue(builder.build(configBuilder.build()).contains("-t")); } @Test public void testMinimalContext() { List<String> arguments = builder.build(minimumContext); Assert.assertEquals("number of arguments.", 16, arguments.size()); assertClassPath(arguments); assertModule(arguments); assertJsDocJs(arguments); Assert.assertFalse(arguments.contains("-l")); } @Test public void testLenientContext() { TaskContext.Builder lenientBuilder = new TaskContext.Builder(minimumBuilder); Assert.assertTrue(builder.build(lenientBuilder.withLeniency(true).build()).contains("-l")); } @Test public void testContextWithConfig() { TaskContext.Builder configBuilder = new TaskContext.Builder(minimumBuilder).withConfigFile(new File("config")); Assert.assertTrue(builder.build(configBuilder.build()).contains("-c")); } @Test public void testContextWithIncludePrivate() { TaskContext.Builder configBuilder = new TaskContext.Builder(minimumBuilder).withIncludePrivate(true); Assert.assertTrue(builder.build(configBuilder.build()).contains("-p")); }
StreamLogger implements Runnable { @Override public void run() { String line; try { while ((line = bufferedReader.readLine()) != null) { log.info(line); } } catch (IOException e) { throw new TaskException("Exception while intercepting stream.", e); } IOUtils.closeQuietly(bufferedReader); IOUtils.closeQuietly(inputStreamReader); } StreamLogger(InputStream in, Log log); @Override void run(); }
@Test(timeout = 1000) public void testSingleLine() { Log mockLog = EasyMock.createStrictMock(Log.class); mockLog.info("Two peas in a bucket."); EasyMock.expectLastCall(); EasyMock.replay(mockLog); InputStream in = new ByteArrayInputStream("Two peas in a bucket.\n".getBytes()); StreamLogger logger = new StreamLogger(in, mockLog); logger.run(); EasyMock.verify(mockLog); } @Test(timeout = 1000) public void testTwoLines() { Log mockLog = EasyMock.createStrictMock(Log.class); mockLog.info("Two peas in a bucket."); mockLog.info("Big ham ham ham."); EasyMock.expectLastCall(); EasyMock.replay(mockLog); InputStream in = new ByteArrayInputStream("Two peas in a bucket.\nBig ham ham ham.\n".getBytes()); StreamLogger logger = new StreamLogger(in, mockLog); logger.run(); EasyMock.verify(mockLog); } @Test(expected = TaskException.class) public void testIoExceptionThrown() { InputStream mockStream = new InputStream() { @Override public int read() throws IOException { throw new IOException("oops"); } }; StreamLogger logger = new StreamLogger(mockStream, new SystemStreamLog()); logger.run(); }
ContinuousWeightedSort extends ContinuousSort { @Override public List<SpruceTimedView> getViewListWithTimeOffsets(ViewGroup parent, List<View> children) { final PointF comparisonPoint = getDistancePoint(parent, children); Collections.sort(children, new Comparator<View>() { @Override public int compare(View v1, View v2) { double leftHorizontalDistance = Utils.horizontalDistance(comparisonPoint, Utils.viewToPoint(v1)) * horizontalWeight; double rightHorizontalDistance = Utils.horizontalDistance(comparisonPoint, Utils.viewToPoint(v2)) * horizontalWeight; double leftVerticalDistance = Utils.verticalDistance(comparisonPoint, Utils.viewToPoint(v1)) * verticalWeight; double rightVerticalDistance = Utils.verticalDistance(comparisonPoint, Utils.viewToPoint(v2)) * verticalWeight; maxHorizontalDistance = calculateMaxDistance(leftHorizontalDistance, rightHorizontalDistance, maxHorizontalDistance); maxVerticalDistance = calculateMaxDistance(leftVerticalDistance, rightVerticalDistance, maxVerticalDistance); return 0; } }); List<SpruceTimedView> timedViews = new ArrayList<>(); long maxTimeOffset = 1; for (View view : children) { double viewHorizontalDistance = Utils.horizontalDistance(comparisonPoint, Utils.viewToPoint(view)) * horizontalWeight; double viewVerticalDistance = Utils.verticalDistance(comparisonPoint, Utils.viewToPoint(view)) * verticalWeight; double normalizedHorizontalDistance = viewHorizontalDistance / maxHorizontalDistance; double normalizedVerticalDistance = viewVerticalDistance / maxVerticalDistance; long offset = Math.round(duration * (normalizedHorizontalDistance * horizontalWeight + normalizedVerticalDistance * verticalWeight)); if (offset > maxTimeOffset) { maxTimeOffset = offset; } if (reversed) { offset = duration - (offset / 2); } timedViews.add(new SpruceTimedView(view, offset)); } return timedViews; } ContinuousWeightedSort(long interObjectDelay, boolean reversed, Position position, @FloatRange(from = 0.0) double horizontalWeight, @FloatRange(from = 0.0) double verticalWeight); @Override List<SpruceTimedView> getViewListWithTimeOffsets(ViewGroup parent, List<View> children); @Override void sortChildren(ViewGroup parent, List<View> children); static final double LIGHT_WEIGHT; static final double MEDIUM_WEIGHT; static final double HEAVY_WEIGHT; }
@Test public void test_positive_inter_object_delay() { List<SpruceTimedView> resultViews = new ContinuousWeightedSort(1, false, RadialSort.Position.TOP_LEFT, ContinuousWeightedSort.MEDIUM_WEIGHT, ContinuousWeightedSort.MEDIUM_WEIGHT) .getViewListWithTimeOffsets(mockParent, mockChildren); Assert.assertEquals(0, resultViews.get(0).getTimeOffset()); Assert.assertEquals(1, resultViews.get(1).getTimeOffset()); Assert.assertEquals(2, resultViews.get(2).getTimeOffset()); } @Test public void test_positive_inter_object_delay_with_reversed() { List<SpruceTimedView> resultViews = new ContinuousWeightedSort(1, true, RadialSort.Position.TOP_LEFT, ContinuousWeightedSort.MEDIUM_WEIGHT, ContinuousWeightedSort.MEDIUM_WEIGHT) .getViewListWithTimeOffsets(mockParent, mockChildren); Assert.assertEquals(1, resultViews.get(0).getTimeOffset()); Assert.assertEquals(1, resultViews.get(1).getTimeOffset()); Assert.assertEquals(0, resultViews.get(2).getTimeOffset()); } @Test public void test_inter_object_delay_of_zero() { List<SpruceTimedView> resultViews = new ContinuousWeightedSort(0, false, RadialSort.Position.TOP_LEFT, ContinuousWeightedSort.MEDIUM_WEIGHT, ContinuousWeightedSort.MEDIUM_WEIGHT) .getViewListWithTimeOffsets(mockParent, mockChildren); Assert.assertEquals(0, resultViews.get(0).getTimeOffset()); Assert.assertEquals(0, resultViews.get(1).getTimeOffset()); Assert.assertEquals(0, resultViews.get(2).getTimeOffset()); } @Test public void test_negative_inter_object_delay() { List<SpruceTimedView> resultViews = new ContinuousWeightedSort(-1, false, RadialSort.Position.TOP_LEFT, ContinuousWeightedSort.MEDIUM_WEIGHT, ContinuousWeightedSort.MEDIUM_WEIGHT) .getViewListWithTimeOffsets(mockParent, mockChildren); Assert.assertEquals(0, resultViews.get(0).getTimeOffset()); Assert.assertEquals(-1, resultViews.get(1).getTimeOffset()); Assert.assertEquals(-2, resultViews.get(2).getTimeOffset()); } @Test public void test_negative_inter_object_delay_with_reversed() { List<SpruceTimedView> resultViews = new ContinuousWeightedSort(-1, true, RadialSort.Position.TOP_LEFT, ContinuousWeightedSort.MEDIUM_WEIGHT, ContinuousWeightedSort.MEDIUM_WEIGHT) .getViewListWithTimeOffsets(mockParent, mockChildren); Assert.assertEquals(-1, resultViews.get(0).getTimeOffset()); Assert.assertEquals(-1, resultViews.get(1).getTimeOffset()); Assert.assertEquals(0, resultViews.get(2).getTimeOffset()); }
CorneredSort extends DistancedSort { @Override public PointF getDistancePoint(ViewGroup parent, List<View> children) { PointF distancePoint; switch (corner) { case TOP_LEFT: distancePoint = new PointF(0, 0); break; case TOP_RIGHT: distancePoint = new PointF(parent.getWidth(), 0); break; case BOTTOM_LEFT: distancePoint = new PointF(0, parent.getHeight()); break; case BOTTOM_RIGHT: distancePoint = new PointF(parent.getWidth(), parent.getHeight()); break; default: throw new AssertionError("Must be a valid Corner argument type"); } return distancePoint; } CorneredSort(long interObjectDelay, boolean reversed, Corner corner); @Override List<SpruceTimedView> getViewListWithTimeOffsets(ViewGroup parent, List<View> children); @Override void sortChildren(ViewGroup parent, List<View> children); @Override PointF getDistancePoint(ViewGroup parent, List<View> children); }
@Test public void test_get_distance_point_for_bottom_left() { corneredSort = new CorneredSort(0, false, CorneredSort.Corner.BOTTOM_LEFT); Mockito.when(mockParent.getHeight()).thenReturn(20); PointF resultPoint = corneredSort.getDistancePoint(mockParent, mockChildren); assertEquals(new PointF(0F, 20F), resultPoint); } @Test public void test_get_distance_point_for_bottom_right() { corneredSort = new CorneredSort(0, false, CorneredSort.Corner.BOTTOM_RIGHT); Mockito.when(mockParent.getWidth()).thenReturn(20); Mockito.when(mockParent.getHeight()).thenReturn(20); PointF resultPoint = corneredSort.getDistancePoint(mockParent, mockChildren); PointF expectedPoint = new PointF(20F, 20F); assertEquals(expectedPoint, resultPoint); } @Test public void test_get_distance_point_for_top_left() { corneredSort = new CorneredSort(0, false, CorneredSort.Corner.TOP_LEFT); PointF resultPoint = corneredSort.getDistancePoint(mockParent, mockChildren); assertEquals(new PointF(0f, 0f), resultPoint); } @Test public void test_get_distance_point_for_top_right() { corneredSort = new CorneredSort(0, false, CorneredSort.Corner.TOP_RIGHT); Mockito.when(mockParent.getWidth()).thenReturn(20); PointF resultPoint = corneredSort.getDistancePoint(mockParent, mockChildren); assertEquals(new PointF(20F, 0F), resultPoint); }
CorneredSort extends DistancedSort { @Override public List<SpruceTimedView> getViewListWithTimeOffsets(ViewGroup parent, List<View> children) { final PointF comparisonPoint = getDistancePoint(parent, children); List<SpruceTimedView> timedViews = new ArrayList<>(); long currentTimeOffset = 0; double lastDistance = 0; for (View view : children) { double viewDistance = getDistanceBetweenPoints(Utils.viewToPoint(view), comparisonPoint); if (Math.floor(lastDistance) != Math.floor(viewDistance)) { lastDistance = viewDistance; currentTimeOffset += interObjectDelay; } timedViews.add(new SpruceTimedView(view, currentTimeOffset)); } return timedViews; } CorneredSort(long interObjectDelay, boolean reversed, Corner corner); @Override List<SpruceTimedView> getViewListWithTimeOffsets(ViewGroup parent, List<View> children); @Override void sortChildren(ViewGroup parent, List<View> children); @Override PointF getDistancePoint(ViewGroup parent, List<View> children); }
@Test public void test_positive_inter_object_delay() { List<SpruceTimedView> resultViews = new CorneredSort(1, false, CorneredSort.Corner.TOP_LEFT) .getViewListWithTimeOffsets(mockParent, mockChildren); assertEquals(0, resultViews.get(0).getTimeOffset()); assertEquals(1, resultViews.get(1).getTimeOffset()); assertEquals(2, resultViews.get(2).getTimeOffset()); } @Test public void test_inter_object_delay_of_zero() { List<SpruceTimedView> resultViews = new CorneredSort(0, false, CorneredSort.Corner.TOP_LEFT) .getViewListWithTimeOffsets(mockParent, mockChildren); assertEquals(0, resultViews.get(0).getTimeOffset()); assertEquals(0, resultViews.get(1).getTimeOffset()); assertEquals(0, resultViews.get(2).getTimeOffset()); } @Test public void test_negative_inter_object_delay() { List<SpruceTimedView> resultViews = new CorneredSort(-1, false, CorneredSort.Corner.TOP_LEFT) .getViewListWithTimeOffsets(mockParent, mockChildren); assertEquals(0, resultViews.get(0).getTimeOffset()); assertEquals(-1, resultViews.get(1).getTimeOffset()); assertEquals(-2, resultViews.get(2).getTimeOffset()); }
InlineSort extends CorneredSort { @Override public List<SpruceTimedView> getViewListWithTimeOffsets(ViewGroup parent, List<View> children) { List<SpruceTimedView> timedViews = new ArrayList<>(); long currentTimeOffset = 0; if (reversed) { Collections.reverse(children); } for (View view : children) { timedViews.add(new SpruceTimedView(view, currentTimeOffset)); currentTimeOffset += interObjectDelay; } return timedViews; } InlineSort(long interObjectDelay, boolean reversed, Corner corner); @Override List<SpruceTimedView> getViewListWithTimeOffsets(ViewGroup parent, List<View> children); @Override void sortChildren(ViewGroup parent, List<View> children); }
@Test public void test_positive_inter_object_delay() { List<SpruceTimedView> resultViews = new InlineSort(1, false, CorneredSort.Corner.BOTTOM_RIGHT) .getViewListWithTimeOffsets(mockParent, mockChildren); Assert.assertEquals(0, resultViews.get(0).getTimeOffset()); Assert.assertEquals(1, resultViews.get(1).getTimeOffset()); Assert.assertEquals(2, resultViews.get(2).getTimeOffset()); } @Test public void test_inter_object_delay_of_zero() { List<SpruceTimedView> resultViews = new InlineSort(0, false, CorneredSort.Corner.BOTTOM_RIGHT) .getViewListWithTimeOffsets(mockParent, mockChildren); Assert.assertEquals(0, resultViews.get(0).getTimeOffset()); Assert.assertEquals(0, resultViews.get(1).getTimeOffset()); Assert.assertEquals(0, resultViews.get(2).getTimeOffset()); } @Test public void test_negative_inter_object_delay() { List<SpruceTimedView> resultViews = new InlineSort(-1, false, CorneredSort.Corner.BOTTOM_RIGHT) .getViewListWithTimeOffsets(mockParent, mockChildren); Assert.assertEquals(0, resultViews.get(0).getTimeOffset()); Assert.assertEquals(-1, resultViews.get(1).getTimeOffset()); Assert.assertEquals(-2, resultViews.get(2).getTimeOffset()); }
DistancedSort extends SortFunction { @Override public List<SpruceTimedView> getViewListWithTimeOffsets(ViewGroup parent, List<View> children) { final PointF comparisonPoint = getDistancePoint(parent, children); double lastDistance = getDistanceBetweenPoints(Utils.viewToPoint(children.get(0)), comparisonPoint); long currentTimeOffset = 0L; List<SpruceTimedView> childViews = new ArrayList<>(); for (View childView : children) { if (lastDistance != getDistanceBetweenPoints(Utils.viewToPoint(childView), comparisonPoint)) { lastDistance = getDistanceBetweenPoints(Utils.viewToPoint(childView), comparisonPoint); currentTimeOffset += interObjectDelay; } childViews.add(new SpruceTimedView(childView, currentTimeOffset)); } return childViews; } DistancedSort(long interObjectDelay, boolean reversed); @Override List<SpruceTimedView> getViewListWithTimeOffsets(ViewGroup parent, List<View> children); @Override void sortChildren(ViewGroup parent, List<View> children); PointF getDistancePoint(ViewGroup parent, List<View> children); double getDistanceBetweenPoints(PointF left, PointF right); }
@Test public void test_positive_inter_object_delay() { List<SpruceTimedView> resultViews = new DistancedSort(1, false) .getViewListWithTimeOffsets(mockParent, mockChildren); Assert.assertEquals(0, resultViews.get(0).getTimeOffset()); Assert.assertEquals(1, resultViews.get(1).getTimeOffset()); Assert.assertEquals(2, resultViews.get(2).getTimeOffset()); } @Test public void test_inter_object_delay_of_zero() { List<SpruceTimedView> resultViews = new DistancedSort(0, false) .getViewListWithTimeOffsets(mockParent, mockChildren); Assert.assertEquals(0, resultViews.get(0).getTimeOffset()); Assert.assertEquals(0, resultViews.get(1).getTimeOffset()); Assert.assertEquals(0, resultViews.get(2).getTimeOffset()); } @Test public void test_negative_inter_object_delay() { List<SpruceTimedView> resultViews = new DistancedSort(-1, false) .getViewListWithTimeOffsets(mockParent, mockChildren); Assert.assertEquals(0, resultViews.get(0).getTimeOffset()); Assert.assertEquals(-1, resultViews.get(1).getTimeOffset()); Assert.assertEquals(-2, resultViews.get(2).getTimeOffset()); } @Test public void test_get_view_list_with_time_offsets_returns_correct_number_of_children() { ViewGroup mockParent = Mockito.mock(ViewGroup.class); List<View> mockChildren = new ArrayList<>(); for (int i = 0; i < 3; i++) { mockChildren.add(Mockito.mock(View.class)); } List<SpruceTimedView> resultViews = new DistancedSort(0, false).getViewListWithTimeOffsets(mockParent, mockChildren); Assert.assertEquals(mockChildren.size(), resultViews.size()); }
DistancedSort extends SortFunction { public PointF getDistancePoint(ViewGroup parent, List<View> children) { PointF distancePoint = new PointF(0, 0); return translate(distancePoint, children); } DistancedSort(long interObjectDelay, boolean reversed); @Override List<SpruceTimedView> getViewListWithTimeOffsets(ViewGroup parent, List<View> children); @Override void sortChildren(ViewGroup parent, List<View> children); PointF getDistancePoint(ViewGroup parent, List<View> children); double getDistanceBetweenPoints(PointF left, PointF right); }
@Test public void test_get_distance_point_returns_a_point() { ViewGroup mockParent = Mockito.mock(ViewGroup.class); List<View> mockChildren = new ArrayList<>(); mockChildren.add(Mockito.mock(View.class)); DistancedSort distancedSort = new DistancedSort(0, false); Assert.assertThat(distancedSort.getDistancePoint(mockParent, mockChildren), CoreMatchers.instanceOf(PointF.class)); }
DistancedSort extends SortFunction { PointF translate(final PointF distancePoint, List<View> children) { Collections.sort(children, new Comparator<View>() { @Override public int compare(View left, View right) { double leftDistance = getDistanceBetweenPoints(Utils.viewToPoint(left), distancePoint); double rightDistance = getDistanceBetweenPoints(Utils.viewToPoint(right), distancePoint); return Double.compare(leftDistance, rightDistance); } }); return Utils.viewToPoint(children.get(0)); } DistancedSort(long interObjectDelay, boolean reversed); @Override List<SpruceTimedView> getViewListWithTimeOffsets(ViewGroup parent, List<View> children); @Override void sortChildren(ViewGroup parent, List<View> children); PointF getDistancePoint(ViewGroup parent, List<View> children); double getDistanceBetweenPoints(PointF left, PointF right); }
@Test public void test_translate_returns_a_point() { List<View> mockChildren = new ArrayList<>(); mockChildren.add(Mockito.mock(View.class)); DistancedSort distancedSort = new DistancedSort(0, false); Assert.assertThat(distancedSort.translate(new PointF(0, 0), mockChildren), CoreMatchers.instanceOf(PointF.class)); }
DistancedSort extends SortFunction { public double getDistanceBetweenPoints(PointF left, PointF right) { return Utils.euclideanDistance(left, right); } DistancedSort(long interObjectDelay, boolean reversed); @Override List<SpruceTimedView> getViewListWithTimeOffsets(ViewGroup parent, List<View> children); @Override void sortChildren(ViewGroup parent, List<View> children); PointF getDistancePoint(ViewGroup parent, List<View> children); double getDistanceBetweenPoints(PointF left, PointF right); }
@Test public void test_get_distance_between_points_returns_a_double() { DistancedSort distancedSort = new DistancedSort(0, false); PointF firstPoint = Mockito.mock(PointF.class); PointF secondPoint = Mockito.mock(PointF.class); Assert.assertThat(distancedSort.getDistanceBetweenPoints(firstPoint, secondPoint), CoreMatchers.instanceOf(Double.class)); }
ContinuousSort extends RadialSort { @Override public List<SpruceTimedView> getViewListWithTimeOffsets(ViewGroup parent, List<View> children) { final PointF comparisonPoint = getDistancePoint(parent, children); double maxDistance = 0; for (View v1: children) { for (View v2: children) { if (v1 != v2) { double leftDistance = getDistanceBetweenPoints(Utils.viewToPoint(v1), comparisonPoint); double rightDistance = getDistanceBetweenPoints(Utils.viewToPoint(v2), comparisonPoint); if (leftDistance > rightDistance && leftDistance > maxDistance) { maxDistance = leftDistance; } } } } List<SpruceTimedView> timedViews = new ArrayList<>(); for (View view : children) { double normalizedDistance; double viewDistance = getDistanceBetweenPoints(Utils.viewToPoint(view), comparisonPoint); if (reversed) { normalizedDistance = (maxDistance - viewDistance) / maxDistance; } else { normalizedDistance = viewDistance / maxDistance; } long offset = Math.round(duration * normalizedDistance); timedViews.add(new SpruceTimedView(view, offset)); } return timedViews; } ContinuousSort(long interObjectDelay, boolean reversed, Position position); @Override List<SpruceTimedView> getViewListWithTimeOffsets(ViewGroup parent, List<View> children); @Override void sortChildren(ViewGroup parent, List<View> children); }
@Test public void test_positive_inter_object_delay() { List<SpruceTimedView> resultViews = new ContinuousSort(1, false, RadialSort.Position.TOP_LEFT) .getViewListWithTimeOffsets(mockParent, mockChildren); Assert.assertEquals(0, resultViews.get(0).getTimeOffset()); Assert.assertEquals(1, resultViews.get(1).getTimeOffset()); Assert.assertEquals(1, resultViews.get(2).getTimeOffset()); } @Test public void test_positive_inter_object_delay_with_reversed() { List<SpruceTimedView> resultViews = new ContinuousSort(1, true, RadialSort.Position.TOP_LEFT) .getViewListWithTimeOffsets(mockParent, mockChildren); Assert.assertEquals(1, resultViews.get(0).getTimeOffset()); Assert.assertEquals(1, resultViews.get(1).getTimeOffset()); Assert.assertEquals(0, resultViews.get(2).getTimeOffset()); } @Test public void test_inter_object_delay_of_zero() { List<SpruceTimedView> resultViews = new ContinuousSort(0, false, RadialSort.Position.TOP_LEFT) .getViewListWithTimeOffsets(mockParent, mockChildren); Assert.assertEquals(0, resultViews.get(0).getTimeOffset()); Assert.assertEquals(0, resultViews.get(1).getTimeOffset()); Assert.assertEquals(0, resultViews.get(2).getTimeOffset()); } @Test public void test_negative_inter_object_delay() { List<SpruceTimedView> resultViews = new ContinuousSort(-1, false, RadialSort.Position.TOP_LEFT) .getViewListWithTimeOffsets(mockParent, mockChildren); Assert.assertEquals(0, resultViews.get(0).getTimeOffset()); Assert.assertEquals(0, resultViews.get(1).getTimeOffset()); Assert.assertEquals(-1, resultViews.get(2).getTimeOffset()); } @Test public void test_negative_inter_object_delay_with_reversed() { List<SpruceTimedView> resultViews = new ContinuousSort(-1, true, RadialSort.Position.TOP_LEFT) .getViewListWithTimeOffsets(mockParent, mockChildren); Assert.assertEquals(-1, resultViews.get(0).getTimeOffset()); Assert.assertEquals(0, resultViews.get(1).getTimeOffset()); Assert.assertEquals(0, resultViews.get(2).getTimeOffset()); }
RandomSort extends SortFunction { @Override public List<SpruceTimedView> getViewListWithTimeOffsets(ViewGroup parent, List<View> children) { List<SpruceTimedView> timedViews = new ArrayList<>(); long currentTimeOffset = 0; for (View view : children) { timedViews.add(new SpruceTimedView(view, currentTimeOffset)); currentTimeOffset += interObjectDelay; } return timedViews; } RandomSort(long interObjectDelay); @Override List<SpruceTimedView> getViewListWithTimeOffsets(ViewGroup parent, List<View> children); @Override void sortChildren(ViewGroup parent, List<View> children); }
@Test public void test_positive_inter_object_delay() { List<SpruceTimedView> resultViews = new RandomSort(1) .getViewListWithTimeOffsets(mockParent, mockChildren); Assert.assertEquals(0, resultViews.get(0).getTimeOffset()); Assert.assertEquals(1, resultViews.get(1).getTimeOffset()); Assert.assertEquals(2, resultViews.get(2).getTimeOffset()); } @Test public void test_inter_object_delay_of_zero() { List<SpruceTimedView> resultViews = new RandomSort(0) .getViewListWithTimeOffsets(mockParent, mockChildren); Assert.assertEquals(0, resultViews.get(0).getTimeOffset()); Assert.assertEquals(0, resultViews.get(1).getTimeOffset()); Assert.assertEquals(0, resultViews.get(2).getTimeOffset()); } @Test public void test_negative_inter_object_delay() { List<SpruceTimedView> resultViews = new RandomSort(-1) .getViewListWithTimeOffsets(mockParent, mockChildren); Assert.assertEquals(0, resultViews.get(0).getTimeOffset()); Assert.assertEquals(-1, resultViews.get(1).getTimeOffset()); Assert.assertEquals(-2, resultViews.get(2).getTimeOffset()); }
RadialSort extends DistancedSort { @Override public PointF getDistancePoint(ViewGroup parent, List<View> children) { PointF distancePoint; switch (position) { case TOP_LEFT: distancePoint = new PointF(0, 0); break; case TOP_MIDDLE: distancePoint = new PointF(parent.getWidth() / 2, 0); break; case TOP_RIGHT: distancePoint = new PointF(parent.getWidth(), 0); break; case LEFT: distancePoint = new PointF(0, parent.getHeight() / 2); break; case MIDDLE: distancePoint = new PointF(parent.getWidth() / 2, parent.getHeight() / 2); break; case RIGHT: distancePoint = new PointF(parent.getWidth(), parent.getHeight() / 2); break; case BOTTOM_LEFT: distancePoint = new PointF(0, parent.getHeight()); break; case BOTTOM_MIDDLE: distancePoint = new PointF(parent.getWidth() / 2, parent.getHeight()); break; case BOTTOM_RIGHT: distancePoint = new PointF(parent.getWidth(), parent.getHeight()); break; default: throw new AssertionError("Must be a valid Position argument type"); } return super.translate(distancePoint, children); } RadialSort(long interObjectDelay, boolean reversed, Position position); @Override PointF getDistancePoint(ViewGroup parent, List<View> children); }
@Test public void test_get_distance_point_for_top_left() { radialSort = new RadialSort(0, false, RadialSort.Position.TOP_LEFT); PointF resultPoint = radialSort.getDistancePoint(mockParent, mockChildren); assertEquals(new PointF(0f, 0f), resultPoint); } @Test public void test_get_distance_point_for_top_middle() { radialSort = new RadialSort(0, false, RadialSort.Position.TOP_MIDDLE); Mockito.when(mockParent.getWidth()).thenReturn(20); setupMockChildrenForPoint(20 / 2, 0); PointF resultPoint = radialSort.getDistancePoint(mockParent, mockChildren); assertEquals(new PointF(10F, 0), resultPoint); } @Test public void test_get_distance_point_for_top_right() { radialSort = new RadialSort(0, false, RadialSort.Position.TOP_RIGHT); Mockito.when(mockParent.getWidth()).thenReturn(20); setupMockChildrenForPoint(20, 0); PointF resultPoint = radialSort.getDistancePoint(mockParent, mockChildren); assertEquals(new PointF(20F, 0), resultPoint); } @Test public void test_get_distance_point_for_left() { radialSort = new RadialSort(0, false, RadialSort.Position.LEFT); Mockito.when(mockParent.getHeight()).thenReturn(20); setupMockChildrenForPoint(0, 20 / 2); PointF resultPoint = radialSort.getDistancePoint(mockParent, mockChildren); assertEquals(new PointF(0, 10F), resultPoint); } @Test public void test_get_distance_point_for_middle() { radialSort = new RadialSort(0, false, RadialSort.Position.MIDDLE); Mockito.when(mockParent.getHeight()).thenReturn(20); Mockito.when(mockParent.getWidth()).thenReturn(20); setupMockChildrenForPoint(20 / 2, 20 / 2); PointF resultPoint = radialSort.getDistancePoint(mockParent, mockChildren); assertEquals(new PointF(10F, 10F), resultPoint); } @Test public void test_get_distance_point_for_right() { radialSort = new RadialSort(0, false, RadialSort.Position.RIGHT); Mockito.when(mockParent.getHeight()).thenReturn(20); Mockito.when(mockParent.getWidth()).thenReturn(20); setupMockChildrenForPoint(20, 20 / 2); PointF resultPoint = radialSort.getDistancePoint(mockParent, mockChildren); assertEquals(new PointF(20F, 10F), resultPoint); } @Test public void test_get_distance_point_for_bottom_left() { radialSort = new RadialSort(0, false, RadialSort.Position.BOTTOM_LEFT); Mockito.when(mockParent.getHeight()).thenReturn(20); setupMockChildrenForPoint(0, 20); PointF resultPoint = radialSort.getDistancePoint(mockParent, mockChildren); assertEquals(new PointF(0F, 20F), resultPoint); } @Test public void test_get_distance_point_for_bottom_middle() { radialSort = new RadialSort(0, false, RadialSort.Position.BOTTOM_MIDDLE); Mockito.when(mockParent.getHeight()).thenReturn(20); Mockito.when(mockParent.getWidth()).thenReturn(20); setupMockChildrenForPoint(20 / 2, 20); PointF resultPoint = radialSort.getDistancePoint(mockParent, mockChildren); assertEquals(new PointF(10F, 20F), resultPoint); } @Test public void test_get_distance_point_for_bottom_right() { radialSort = new RadialSort(0, false, RadialSort.Position.BOTTOM_RIGHT); Mockito.when(mockParent.getWidth()).thenReturn(20); Mockito.when(mockParent.getHeight()).thenReturn(20); setupMockChildrenForPoint(20, 20); PointF resultPoint = radialSort.getDistancePoint(mockParent, mockChildren); assertEquals(new PointF(20F, 20F), resultPoint); }
DefaultSort extends SortFunction { @Override public List<SpruceTimedView> getViewListWithTimeOffsets(ViewGroup parent, List<View> children) { List<SpruceTimedView> childTimedViews = new ArrayList<>(); long currentTimeOffset = 0L; for (View childView : children) { childTimedViews.add(new SpruceTimedView(childView, currentTimeOffset)); currentTimeOffset += interObjectDelay; } return childTimedViews; } DefaultSort(long interObjectDelay); @Override List<SpruceTimedView> getViewListWithTimeOffsets(ViewGroup parent, List<View> children); @Override void sortChildren(ViewGroup parent, List<View> children); }
@Test public void test_inter_object_delay_of_views_is_set_on_default_sort() { List<SpruceTimedView> resultViews = new DefaultSort(1) .getViewListWithTimeOffsets(mockParent, mockChildren); Assert.assertEquals(0, resultViews.get(0).getTimeOffset()); Assert.assertEquals(1, resultViews.get(1).getTimeOffset()); Assert.assertEquals(2, resultViews.get(2).getTimeOffset()); } @Test public void test_inter_object_delay_of_zero() { List<SpruceTimedView> resultViews = new DefaultSort(0) .getViewListWithTimeOffsets(mockParent, mockChildren); Assert.assertEquals(0, resultViews.get(0).getTimeOffset()); Assert.assertEquals(0, resultViews.get(1).getTimeOffset()); Assert.assertEquals(0, resultViews.get(2).getTimeOffset()); } @Test public void test_negative_inter_object_delay() { List<SpruceTimedView> resultViews = new DefaultSort(-1) .getViewListWithTimeOffsets(mockParent, mockChildren); Assert.assertEquals(0, resultViews.get(0).getTimeOffset()); Assert.assertEquals(-1, resultViews.get(1).getTimeOffset()); Assert.assertEquals(-2, resultViews.get(2).getTimeOffset()); }
ContinuousWeightedSort extends ContinuousSort { @VisibleForTesting double calculateMaxDistance(double leftHorizontalDistance, double rightHorizontalDistance, double maximum) { if (leftHorizontalDistance > rightHorizontalDistance && leftHorizontalDistance > maximum) { maximum = leftHorizontalDistance; } else if (rightHorizontalDistance > leftHorizontalDistance && rightHorizontalDistance > maximum) { maximum = rightHorizontalDistance; } return maximum; } ContinuousWeightedSort(long interObjectDelay, boolean reversed, Position position, @FloatRange(from = 0.0) double horizontalWeight, @FloatRange(from = 0.0) double verticalWeight); @Override List<SpruceTimedView> getViewListWithTimeOffsets(ViewGroup parent, List<View> children); @Override void sortChildren(ViewGroup parent, List<View> children); static final double LIGHT_WEIGHT; static final double MEDIUM_WEIGHT; static final double HEAVY_WEIGHT; }
@Test public void test_calculate_max_distance() { ContinuousWeightedSort continuousWeightedSort = new ContinuousWeightedSort(0, false, RadialSort.Position.TOP_LEFT, ContinuousWeightedSort.MEDIUM_WEIGHT, ContinuousWeightedSort.MEDIUM_WEIGHT); double max = 0; max = continuousWeightedSort.calculateMaxDistance(5, 4, max); Assert.assertEquals(5, max, 0); } @Test public void test_calculate_max_distance_with_greater_right_value() { ContinuousWeightedSort continuousWeightedSort = new ContinuousWeightedSort(0, false, RadialSort.Position.TOP_LEFT, ContinuousWeightedSort.MEDIUM_WEIGHT, ContinuousWeightedSort.MEDIUM_WEIGHT); double max = 0; max = continuousWeightedSort.calculateMaxDistance(5, 6, max); Assert.assertEquals(6, max, 0); } @Test public void test_calculate_max_distance_with_equal_left_and_right_values() { ContinuousWeightedSort continuousWeightedSort = new ContinuousWeightedSort(0, false, RadialSort.Position.TOP_LEFT, ContinuousWeightedSort.MEDIUM_WEIGHT, ContinuousWeightedSort.MEDIUM_WEIGHT); double max = 0; max = continuousWeightedSort.calculateMaxDistance(1, 1, max); Assert.assertEquals(0, max, 0); }
PopupBridge extends BrowserSwitchFragment { @SuppressLint("SetJavaScriptEnabled") public static PopupBridge newInstance(AppCompatActivity activity, WebView webView) throws IllegalArgumentException { return newInstance((FragmentActivity)activity, webView); } PopupBridge(); @SuppressLint("SetJavaScriptEnabled") static PopupBridge newInstance(AppCompatActivity activity, WebView webView); @SuppressLint("SetJavaScriptEnabled") static PopupBridge newInstance(FragmentActivity activity, WebView webView); @Override void onAttach(@NonNull Context context); @Override void onCreate(Bundle savedInstanceState); @Override void onBrowserSwitchResult(int requestCode, BrowserSwitchResult result, @Nullable Uri returnUri); @Override String getReturnUrlScheme(); @JavascriptInterface String getReturnUrlPrefix(); @JavascriptInterface void open(String url); @JavascriptInterface void sendMessage(String messageName); @JavascriptInterface void sendMessage(String messageName, String data); void setNavigationListener(PopupBridgeNavigationListener listener); void setMessageListener(PopupBridgeMessageListener listener); static final String POPUP_BRIDGE_NAME; static final String POPUP_BRIDGE_URL_HOST; }
@Test public void newInstance_whenActivityIsNull_throwsException() { Exception thrownException = null; AppCompatTestActivity appCompatTestActivity = Robolectric.setupActivity(AppCompatTestActivity.class); WebView webView = new WebView(appCompatTestActivity); try { PopupBridge.newInstance(null, webView); } catch (IllegalArgumentException e){ thrownException = e; } finally { assertEquals(thrownException.getMessage(), "Activity is null"); } } @Test public void newInstance_whenWebViewIsNull_throwsException() { Exception thrownException = null; try { PopupBridge.newInstance(new AppCompatTestActivity(), null); } catch (IllegalArgumentException e){ thrownException = e; } finally { assertEquals(thrownException.getMessage(), "WebView is null"); } } @Test public void newInstance_enablesJavascriptOnWebView() { WebView webView = mock(WebView.class); WebSettings webSettings = mock(WebSettings.class); when(webView.getSettings()).thenReturn(webSettings); PopupBridge.newInstance(mAppCompatActivity, webView); verify(webSettings).setJavaScriptEnabled(eq(true)); } @Test public void newInstance_fragmentActivity_enablesJavascriptOnWebView() { WebView webView = mock(WebView.class); WebSettings webSettings = mock(WebSettings.class); when(webView.getSettings()).thenReturn(webSettings); PopupBridge.newInstance(mFragmentActivity, webView); verify(webSettings).setJavaScriptEnabled(eq(true)); } @Test @SuppressLint("JavascriptInterface") public void newInstance_addsJavascriptInterfaceToWebView() { WebView webView = mock(WebView.class); when(webView.getSettings()).thenReturn(mock(WebSettings.class)); PopupBridge popupBridge = PopupBridge.newInstance(mAppCompatActivity, webView); verify(webView).addJavascriptInterface(eq(popupBridge), eq("popupBridge")); }
PopupBridge extends BrowserSwitchFragment { @Override public void onBrowserSwitchResult(int requestCode, BrowserSwitchResult result, @Nullable Uri returnUri) { String error = null; String payload = null; if (result.getStatus() == BrowserSwitchResult.STATUS_CANCELED) { runJavaScriptInWebView("" + "if (typeof window.popupBridge.onCancel === 'function') {" + " window.popupBridge.onCancel();" + "} else {" + " window.popupBridge.onComplete(null, null);" + "}"); return; } else if (result.getStatus() == BrowserSwitchResult.STATUS_OK) { if (returnUri == null || !returnUri.getScheme().equals(getReturnUrlScheme()) || !returnUri.getHost().equals(POPUP_BRIDGE_URL_HOST)) { return; } JSONObject json = new JSONObject(); JSONObject queryItems = new JSONObject(); Set<String> queryParams = returnUri.getQueryParameterNames(); if (queryParams != null && !queryParams.isEmpty()) { for (String queryParam : queryParams) { try { queryItems.put(queryParam, returnUri.getQueryParameter(queryParam)); } catch (JSONException e) { error = "new Error('Failed to parse query items from return URL. " + e.getLocalizedMessage() + "')"; } } } try { json.put("path", returnUri.getPath()); json.put("queryItems", queryItems); json.put("hash", returnUri.getFragment()); } catch (JSONException ignored) {} payload = json.toString(); } else if (result.getStatus() == BrowserSwitchResult.STATUS_ERROR) { error = "new Error('" + result.getErrorMessage() + "')"; } runJavaScriptInWebView(String.format("window.popupBridge.onComplete(%s, %s);", error, payload)); } PopupBridge(); @SuppressLint("SetJavaScriptEnabled") static PopupBridge newInstance(AppCompatActivity activity, WebView webView); @SuppressLint("SetJavaScriptEnabled") static PopupBridge newInstance(FragmentActivity activity, WebView webView); @Override void onAttach(@NonNull Context context); @Override void onCreate(Bundle savedInstanceState); @Override void onBrowserSwitchResult(int requestCode, BrowserSwitchResult result, @Nullable Uri returnUri); @Override String getReturnUrlScheme(); @JavascriptInterface String getReturnUrlPrefix(); @JavascriptInterface void open(String url); @JavascriptInterface void sendMessage(String messageName); @JavascriptInterface void sendMessage(String messageName, String data); void setNavigationListener(PopupBridgeNavigationListener listener); void setMessageListener(PopupBridgeMessageListener listener); static final String POPUP_BRIDGE_NAME; static final String POPUP_BRIDGE_URL_HOST; }
@Test public void onBrowserSwitchResult_whenReturnUrlIncludesFragmentIdentifier_reportsPayloadWithFragmentIdentifier() throws JSONException { BrowserSwitchResult result = mock(BrowserSwitchResult.class); when(result.getStatus()).thenReturn(BrowserSwitchResult.STATUS_OK); Uri uri = new Uri.Builder() .scheme(mAppCompatActivity.getApplicationContext().getPackageName() + ".popupbridge") .authority("popupbridgev1") .fragment("hashValue") .build(); mPopupBridge.onBrowserSwitchResult(1, result, uri); assertEquals("null", mWebView.mError); JSONObject payload = new JSONObject(mWebView.mPayload); assertEquals("hashValue", payload.getString("hash")); } @Test public void onBrowserSwitchResult_whenReturnUrlExcludesFragmentIdentifier_fragmentIdentifierIsNotReturned() throws JSONException { BrowserSwitchResult result = mock(BrowserSwitchResult.class); when(result.getStatus()).thenReturn(BrowserSwitchResult.STATUS_OK); Uri uri = new Uri.Builder() .scheme(mAppCompatActivity.getApplicationContext().getPackageName() + ".popupbridge") .authority("popupbridgev1") .build(); mPopupBridge.onBrowserSwitchResult(1, result, uri); assertEquals("null", mWebView.mError); JSONObject payload = new JSONObject(mWebView.mPayload); assertEquals("", payload.getString("path")); assertFalse(payload.has("hash")); } @Test public void onBrowserSwitchResult_whenResultIsError_reportsError() { BrowserSwitchResult result = mock(BrowserSwitchResult.class); when(result.getStatus()).thenReturn(BrowserSwitchResult.STATUS_ERROR); when(result.getErrorMessage()).thenReturn("Browser switch error"); mPopupBridge.onBrowserSwitchResult(1, result, null); assertEquals("new Error('Browser switch error')", mWebView.mError); assertEquals(mWebView.mJavascriptEval, "window.popupBridge.onComplete(new Error('Browser switch error'), null);"); } @Test public void onActivityResult_whenNoPath_returnsEmptyString() throws JSONException { BrowserSwitchResult result = mock(BrowserSwitchResult.class); when(result.getStatus()).thenReturn(BrowserSwitchResult.STATUS_OK); Uri uri = new Uri.Builder() .scheme(mAppCompatActivity.getApplicationContext().getPackageName() + ".popupbridge") .authority("popupbridgev1") .build(); mPopupBridge.onBrowserSwitchResult(1, result, uri); assertEquals("null", mWebView.mError); JSONObject payload = new JSONObject(mWebView.mPayload); assertEquals(payload.getString("path"), ""); assertEquals(payload.getJSONObject("queryItems").length(), 0); } @Test public void onBrowserSwitchResult_whenNotPopupBridgeRequest_doesNotCallOnComplete() { BrowserSwitchResult result = mock(BrowserSwitchResult.class); when(result.getStatus()).thenReturn(BrowserSwitchResult.STATUS_OK); mPopupBridge.onBrowserSwitchResult(1, result, null); assertNull(mWebView.mError); assertNull(mWebView.mPayload); } @Test public void onBrowserSwitchResult_whenCancelled_callsPopupBridgeOnCancelMethod() { BrowserSwitchResult result = mock(BrowserSwitchResult.class); when(result.getStatus()).thenReturn(BrowserSwitchResult.STATUS_CANCELED); Uri uri = new Uri.Builder() .scheme(mAppCompatActivity.getApplicationContext().getPackageName() + ".popupbridge") .authority("popupbridgev1") .build(); mPopupBridge.onBrowserSwitchResult(1, result, uri); assertEquals(mWebView.mError, "null"); assertEquals(mWebView.mPayload, "null"); assertThat(mWebView.mJavascriptEval, containsString("window.popupBridge.onCancel()")); assertThat(mWebView.mJavascriptEval, containsString("window.popupBridge.onComplete(null, null)")); } @Test public void onBrowserSwitchResult_whenDifferentScheme_doesNotCallOnComplete() { BrowserSwitchResult result = mock(BrowserSwitchResult.class); when(result.getStatus()).thenReturn(BrowserSwitchResult.STATUS_OK); Uri uri = new Uri.Builder() .scheme("com.oranges.popupbridge") .path("mypath") .build(); mPopupBridge.onBrowserSwitchResult(1, result, uri); assertNull(mWebView.mError); assertNull(mWebView.mPayload); assertNull(mWebView.mJavascriptEval); } @Test public void onBrowserSwitchResult_whenReturnUrlHasQueryParams_reportsPayloadWithQueryItems() throws JSONException { BrowserSwitchResult result = mock(BrowserSwitchResult.class); when(result.getStatus()).thenReturn(BrowserSwitchResult.STATUS_OK); Uri uri = new Uri.Builder() .scheme(mAppCompatActivity.getApplicationContext().getPackageName() + ".popupbridge") .authority("popupbridgev1") .path("mypath") .appendQueryParameter("foo", "bar") .appendQueryParameter("baz", "qux") .build(); mPopupBridge.onBrowserSwitchResult(1, result, uri); assertEquals("null", mWebView.mError); JSONObject payload = new JSONObject(mWebView.mPayload); assertEquals(payload.getString("path"), "/mypath"); assertEquals(payload.getJSONObject("queryItems").getString("foo"), "bar"); assertEquals(payload.getJSONObject("queryItems").getString("baz"), "qux"); assertEquals(payload.getJSONObject("queryItems").length(), 2); assertThat(mWebView.mJavascriptEval, containsString("window.popupBridge.onComplete(null, {")); } @Test public void onBrowserSwitchResult_whenReturnUrlHasNoQueryParams_reportsPayloadWithEmptyQueryItems() throws JSONException { BrowserSwitchResult result = mock(BrowserSwitchResult.class); when(result.getStatus()).thenReturn(BrowserSwitchResult.STATUS_OK); Uri uri = new Uri.Builder() .scheme(mAppCompatActivity.getApplicationContext().getPackageName() + ".popupbridge") .authority("popupbridgev1") .path("mypath") .build(); mPopupBridge.onBrowserSwitchResult(1, result, uri); assertEquals("null", mWebView.mError); JSONObject payload = new JSONObject(mWebView.mPayload); assertEquals(payload.getString("path"), "/mypath"); assertEquals(payload.getJSONObject("queryItems").length(), 0); }
PopupBridge extends BrowserSwitchFragment { @Override public String getReturnUrlScheme() { return mReturnUrlScheme; } PopupBridge(); @SuppressLint("SetJavaScriptEnabled") static PopupBridge newInstance(AppCompatActivity activity, WebView webView); @SuppressLint("SetJavaScriptEnabled") static PopupBridge newInstance(FragmentActivity activity, WebView webView); @Override void onAttach(@NonNull Context context); @Override void onCreate(Bundle savedInstanceState); @Override void onBrowserSwitchResult(int requestCode, BrowserSwitchResult result, @Nullable Uri returnUri); @Override String getReturnUrlScheme(); @JavascriptInterface String getReturnUrlPrefix(); @JavascriptInterface void open(String url); @JavascriptInterface void sendMessage(String messageName); @JavascriptInterface void sendMessage(String messageName, String data); void setNavigationListener(PopupBridgeNavigationListener listener); void setMessageListener(PopupBridgeMessageListener listener); static final String POPUP_BRIDGE_NAME; static final String POPUP_BRIDGE_URL_HOST; }
@Test public void getReturnUrlScheme_returnsExpectedUrlScheme() { assertEquals(mPopupBridge.getReturnUrlScheme(), mAppCompatActivity.getApplicationContext().getPackageName() + ".popupbridge"); }
PopupBridge extends BrowserSwitchFragment { @JavascriptInterface public String getReturnUrlPrefix() { return String.format("%s: } PopupBridge(); @SuppressLint("SetJavaScriptEnabled") static PopupBridge newInstance(AppCompatActivity activity, WebView webView); @SuppressLint("SetJavaScriptEnabled") static PopupBridge newInstance(FragmentActivity activity, WebView webView); @Override void onAttach(@NonNull Context context); @Override void onCreate(Bundle savedInstanceState); @Override void onBrowserSwitchResult(int requestCode, BrowserSwitchResult result, @Nullable Uri returnUri); @Override String getReturnUrlScheme(); @JavascriptInterface String getReturnUrlPrefix(); @JavascriptInterface void open(String url); @JavascriptInterface void sendMessage(String messageName); @JavascriptInterface void sendMessage(String messageName, String data); void setNavigationListener(PopupBridgeNavigationListener listener); void setMessageListener(PopupBridgeMessageListener listener); static final String POPUP_BRIDGE_NAME; static final String POPUP_BRIDGE_URL_HOST; }
@Test public void getReturnUrlPrefix_returnsExpectedUrlPrefix() { assertEquals(mPopupBridge.getReturnUrlPrefix(), mAppCompatActivity.getApplicationContext().getPackageName() + ".popupbridge: }
PersistentStore { static void put(String key, String value, Context context) { Context applicationContext = context.getApplicationContext(); SharedPreferences sharedPreferences = applicationContext.getSharedPreferences(PREFERENCES_KEY, Context.MODE_PRIVATE); sharedPreferences.edit().putString(key, value).apply(); } }
@Test public void put_placesKeyValuePairIntoSharedPrefs() { when( sharedPreferencesEditor.putString(anyString(), anyString()) ).thenReturn(sharedPreferencesEditor); PersistentStore.put("key", "value", context); InOrder inOrder = Mockito.inOrder(sharedPreferencesEditor); inOrder.verify(sharedPreferencesEditor).putString("key", "value"); inOrder.verify(sharedPreferencesEditor).apply(); }
BrowserSwitchFragment extends Fragment implements BrowserSwitchListener { @SuppressWarnings("WeakerAccess") public void browserSwitch(int requestCode, String url) { BrowserSwitchOptions browserSwitchOptions = new BrowserSwitchOptions() .requestCode(requestCode) .url(Uri.parse(url)); browserSwitchClient.start(browserSwitchOptions, this); } @Override void onAttach(@NonNull Context context); @Override void onCreate(Bundle savedInstanceState); @Override void onResume(); String getReturnUrlScheme(); @SuppressWarnings("WeakerAccess") void browserSwitch(int requestCode, String url); @SuppressWarnings("WeakerAccess") void browserSwitch(int requestCode, Intent intent); void browserSwitch(BrowserSwitchOptions browserSwitchOptions); abstract void onBrowserSwitchResult(int requestCode, BrowserSwitchResult result, @Nullable Uri returnUri); }
@Test public void browserSwitchWithOptions_startsBrowserSwitch() { sut.browserSwitchClient = browserSwitchClient; BrowserSwitchOptions browserSwitchOptions = new BrowserSwitchOptions(); sut.browserSwitch(browserSwitchOptions); verify(browserSwitchClient).start(browserSwitchOptions, sut); } @Test public void browserSwitchWithUri_startsBrowserSwitch() { sut.browserSwitchClient = browserSwitchClient; sut.browserSwitch(123, "https: Uri uri = Uri.parse("https: ArgumentCaptor<BrowserSwitchOptions> captor = ArgumentCaptor.forClass(BrowserSwitchOptions.class); verify(browserSwitchClient).start(captor.capture(), same(sut)); BrowserSwitchOptions browserSwitchOptions = captor.getValue(); assertEquals(browserSwitchOptions.getRequestCode(), 123); assertEquals(browserSwitchOptions.getUrl(), uri); } @Test public void browserSwitchWithIntent_startsBrowserSwitch() { Intent intent = new Intent(); sut.browserSwitchClient = browserSwitchClient; sut.browserSwitch(123, intent); ArgumentCaptor<BrowserSwitchOptions> captor = ArgumentCaptor.forClass(BrowserSwitchOptions.class); verify(browserSwitchClient).start(captor.capture(), same(sut)); BrowserSwitchOptions browserSwitchOptions = captor.getValue(); assertEquals(browserSwitchOptions.getRequestCode(), 123); assertEquals(browserSwitchOptions.getIntent(), intent); }
PersistentStore { static String get(String key, Context context) { Context applicationContext = context.getApplicationContext(); SharedPreferences sharedPreferences = applicationContext.getSharedPreferences(PREFERENCES_KEY, Context.MODE_PRIVATE); return sharedPreferences.getString(key, null); } }
@Test public void get_retrievesValueFromSharedPrefsByKey() { when(sharedPreferences.getString("key", null)).thenReturn("sampleValue"); String result = PersistentStore.get("key", context); assertEquals(result, "sampleValue"); }
PersistentStore { static void remove(String key, Context context) { Context applicationContext = context.getApplicationContext(); SharedPreferences sharedPreferences = applicationContext.getSharedPreferences(PREFERENCES_KEY, Context.MODE_PRIVATE); sharedPreferences.edit().remove(key).apply(); } }
@Test public void remove_removesValueInSharedPrefsByKey() { when(sharedPreferencesEditor.remove(anyString())).thenReturn(sharedPreferencesEditor); PersistentStore.remove("key", context); InOrder inOrder = Mockito.inOrder(sharedPreferencesEditor); inOrder.verify(sharedPreferencesEditor).remove("key"); inOrder.verify(sharedPreferencesEditor).apply(); }
BrowserSwitchConfig { Intent createIntentToLaunchUriInBrowser(Context context, Uri uri) { Intent intent = new Intent(Intent.ACTION_VIEW, uri); intent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK); Context applicationContext = context.getApplicationContext(); if (ChromeCustomTabs.isAvailable(applicationContext)) { ChromeCustomTabs.addChromeCustomTabsExtras(applicationContext, intent); } return intent; } }
@Test public void createIntentToLaunchUriInBrowser_returnsIntent() { when(context.getApplicationContext()).thenReturn(applicationContext); when(ChromeCustomTabs.isAvailable(applicationContext)).thenReturn(false); Uri uri = Uri.parse("https: Intent result = sut.createIntentToLaunchUriInBrowser(context, uri); assertEquals(result.getData().toString(), "https: assertEquals(result.getAction(), Intent.ACTION_VIEW); assertEquals(result.getFlags(), Intent.FLAG_ACTIVITY_NEW_TASK); verifyStatic(ChromeCustomTabs.class, never()); ChromeCustomTabs.addChromeCustomTabsExtras(applicationContext, result); } @Test public void createIntentToLaunchUriInBrowser_optionallyConfiguresIntentForChromeCustomTabs() { when(context.getApplicationContext()).thenReturn(applicationContext); when(ChromeCustomTabs.isAvailable(applicationContext)).thenReturn(true); Uri uri = Uri.parse("https: Intent result = sut.createIntentToLaunchUriInBrowser(context, uri); assertEquals(result.getData().toString(), "https: assertEquals(result.getAction(), Intent.ACTION_VIEW); assertEquals(result.getFlags(), Intent.FLAG_ACTIVITY_NEW_TASK); verifyStatic(ChromeCustomTabs.class); ChromeCustomTabs.addChromeCustomTabsExtras(applicationContext, result); }
BrowserSwitchConfig { Intent createIntentForBrowserSwitchActivityQuery(String returnUrlScheme) { String browserSwitchUrl = String.format("%s: Intent intent = new Intent(Intent.ACTION_VIEW, Uri.parse(browserSwitchUrl)); intent.addCategory(Intent.CATEGORY_DEFAULT); intent.addCategory(Intent.CATEGORY_BROWSABLE); return intent; } }
@Test public void createIntentForBrowserSwitchActivityQuery_configuresAndReturnsIntent() { when(context.getApplicationContext()).thenReturn(applicationContext); when(applicationContext.getPackageName()).thenReturn("sample.package.name"); String returnUrlScheme = "sample.package.name.browserswitch"; Intent result = sut.createIntentForBrowserSwitchActivityQuery(returnUrlScheme); assertEquals(result.getData().toString(), "sample.package.name.browserswitch: assertEquals(result.getAction(), Intent.ACTION_VIEW); assertTrue(result.hasCategory(Intent.CATEGORY_DEFAULT)); assertTrue(result.hasCategory(Intent.CATEGORY_BROWSABLE)); }
BrowserSwitchFragment extends Fragment implements BrowserSwitchListener { @Override public void onResume() { super.onResume(); browserSwitchClient.deliverResult(this); } @Override void onAttach(@NonNull Context context); @Override void onCreate(Bundle savedInstanceState); @Override void onResume(); String getReturnUrlScheme(); @SuppressWarnings("WeakerAccess") void browserSwitch(int requestCode, String url); @SuppressWarnings("WeakerAccess") void browserSwitch(int requestCode, Intent intent); void browserSwitch(BrowserSwitchOptions browserSwitchOptions); abstract void onBrowserSwitchResult(int requestCode, BrowserSwitchResult result, @Nullable Uri returnUri); }
@Test public void onResume_deliversBrowserSwitchResultViaClient() { sut.browserSwitchClient = browserSwitchClient; sut.onResume(); verify(browserSwitchClient).deliverResult(sut); }
BrowserSwitchFragment extends Fragment implements BrowserSwitchListener { public String getReturnUrlScheme() { return returnUrlScheme; } @Override void onAttach(@NonNull Context context); @Override void onCreate(Bundle savedInstanceState); @Override void onResume(); String getReturnUrlScheme(); @SuppressWarnings("WeakerAccess") void browserSwitch(int requestCode, String url); @SuppressWarnings("WeakerAccess") void browserSwitch(int requestCode, Intent intent); void browserSwitch(BrowserSwitchOptions browserSwitchOptions); abstract void onBrowserSwitchResult(int requestCode, BrowserSwitchResult result, @Nullable Uri returnUri); }
@Test public void getReturnUrlScheme_returnsUrlSchemeUsingPackageNameFromContext() { String result = sut.getReturnUrlScheme(); assertEquals(result, "com.braintreepayments.browserswitch.test.browserswitch"); }
UpdateIntelliJSdksTask extends DefaultTask { @TaskAction public void exec() throws IOException { Path userHome = Paths.get(System.getProperty("user.home")); final List<Path> intelliJFolders; try (var files = Files.list(userHome)) { intelliJFolders = files .filter( path -> Files.isDirectory(path) && (path.getFileName().toString().startsWith(".IntelliJIdea") || path.getFileName().toString().startsWith(".IdeaIC"))) .sorted() .collect(toImmutableList()); } final Path intelliJFolder; if (!intelliJFolders.isEmpty()) { intelliJFolder = Iterables.getLast(intelliJFolders); } else { getProject() .getLogger() .info("No IntelliJ config folder found, writing to default location."); intelliJFolder = userHome.resolve(LATEST_INTELLIJ_CONFIG_FOLDER); } getProject() .getLogger() .info("Updating IntelliJ folder {}, found folders {}", intelliJFolder, intelliJFolders); String javaVersion = ToolDependencies.getOpenJdkVersion(getProject()); String majorVersion = javaVersion.startsWith("zulu") ? JavaVersion.toVersion(javaVersion.substring("zulu".length())).getMajorVersion() : JavaVersion.toVersion(javaVersion).getMajorVersion(); String java8Version = ToolDependencies.getOpenJdk8Version(getProject()); final String jdk8FolderSuffix; switch (new PlatformHelper().getOs()) { case WINDOWS: jdk8FolderSuffix = "win_x64"; break; case MAC_OSX: jdk8FolderSuffix = "macosx_x64"; break; case LINUX: jdk8FolderSuffix = "linux_x64"; break; default: throw new IllegalStateException("Unknown OS"); } String jdk8FolderName = java8Version + "/" + java8Version + "-" + jdk8FolderSuffix; var jdkTable = Files.createDirectories(intelliJFolder.resolve("config/options")).resolve("jdk.table.xml"); updateConfig( jdkTable, "jdk-" + javaVersion, majorVersion, "curiostack/openjdk-intellij-table-snippet.template.xml", ImmutableMap.of( "javaVersion", javaVersion, "javaModules", JAVA_MODULES, "majorVersion", majorVersion), getProject()); updateConfig( jdkTable, jdk8FolderName, "1.8", "curiostack/openjdk-8-intellij-table-snippet.template.xml", ImmutableMap.of("javaVersion", java8Version, "javaModules", JAVA_8_JARS), getProject()); updateGoSdk(intelliJFolder, getProject()); updateGoPath(intelliJFolder, getProject()); } @TaskAction void exec(); static final String NAME; }
@Test void noIntelliJFolders() throws Exception { task.exec(); assertNoExistingConfig( testUserHome.resolve(UpdateIntelliJSdksTask.LATEST_INTELLIJ_CONFIG_FOLDER)); } @Test void noExistingFile() throws Exception { Path intelliJFolder = Files.createDirectories(testUserHome.resolve(".IntelliJIdea2019.1")); task.exec(); assertNoExistingConfig(intelliJFolder); } @Test void noExistingFile_community() throws Exception { Path intelliJFolder = Files.createDirectories(testUserHome.resolve(".IdeaIC2019.1")); task.exec(); assertNoExistingConfig(intelliJFolder); testTemplate("update-intellij-jdks-task-test-tables/only-curio-openjdk.template.xml"); } @Test void existingUnrelated() throws Exception { Path optionsFolder = Files.createDirectories(testUserHome.resolve(".IntelliJIdea2019.1/config/options")); Files.writeString( optionsFolder.resolve("jdk.table.xml"), resource("update-intellij-jdks-task-test-tables/existing-unrelated.xml")); Files.writeString( optionsFolder.resolve("go.sdk.xml"), resource("update-intellij-jdks-task-test-tables/existing-gosdk.xml")); Files.writeString( optionsFolder.resolve("goLibraries.xml"), resource("update-intellij-jdks-task-test-tables/existing-gopath.xml")); task.exec(); assertThat(optionsFolder.resolve("jdk.table.xml")) .hasContent( testTemplate( "update-intellij-jdks-task-test-tables/existing-and-curio-openjdk.template.xml")); assertThat(optionsFolder.resolve("go.sdk.xml")) .hasContent( testTemplate( "update-intellij-jdks-task-test-tables/existing-and-curio-gosdk.template.xml")); assertThat(optionsFolder.resolve("goLibraries.xml")) .hasContent( testTemplate( "update-intellij-jdks-task-test-tables/existing-and-curio-gopath.template.xml")); } @Test void existingRelated() throws Exception { Path optionsFolder = Files.createDirectories(testUserHome.resolve(".IntelliJIdea2019.1/config/options")); Files.writeString( optionsFolder.resolve("jdk.table.xml"), resource("update-intellij-jdks-task-test-tables/existing-related.xml")); Files.writeString( optionsFolder.resolve("go.sdk.xml"), testTemplate("update-intellij-jdks-task-test-tables/only-curio-gosdk.template.xml")); Files.writeString( optionsFolder.resolve("goLibraries.xml"), testTemplate("update-intellij-jdks-task-test-tables/only-curio-gopath.template.xml")); task.exec(); assertThat(optionsFolder.resolve("jdk.table.xml")) .hasContent( testTemplate( "update-intellij-jdks-task-test-tables/existing-and-curio-openjdk.template.xml")); assertThat(optionsFolder.resolve("go.sdk.xml")) .hasContent( testTemplate("update-intellij-jdks-task-test-tables/only-curio-gosdk.template.xml")); assertThat(optionsFolder.resolve("goLibraries.xml")) .hasContent( testTemplate("update-intellij-jdks-task-test-tables/only-curio-gopath.template.xml")); }
ECDSA256Verifier { public boolean verify(byte[] payload, byte[] payloadSignature) { final Signature signature; try { signature = Signature.getInstance("SHA256withECDSA"); } catch (NoSuchAlgorithmException e) { throw new IllegalStateException( "Could not load ECDSA algorithm. Is bouncycastle on the classpath?"); } try { signature.initVerify(publicKey); } catch (InvalidKeyException e) { throw new IllegalStateException("Public key not an ECDSA key.", e); } try { signature.update(payload); return signature.verify(payloadSignature); } catch (SignatureException e) { logger.warn("Invalid signature.", e); return false; } } @Inject ECDSA256Verifier(SignerConfig config); boolean verify(byte[] payload, byte[] payloadSignature); }
@Test public void validSignatureInvalidPayload() { byte[] payload = "highlysensitiveinformation".getBytes(StandardCharsets.UTF_8); byte[] signature = signer.sign(payload); assertThat(verifier.verify("interceptedpayload".getBytes(StandardCharsets.UTF_8), signature)) .isFalse(); } @Test public void validPayloadInvalidSignature() { byte[] payload = "highlysensitiveinformation".getBytes(StandardCharsets.UTF_8); assertThat(verifier.verify(payload, "badsignature".getBytes(StandardCharsets.UTF_8))).isFalse(); }
ECDSA256Signer { public byte[] sign(byte[] payload) { final Signature signature; try { signature = Signature.getInstance("SHA256withECDSA"); } catch (NoSuchAlgorithmException e) { throw new IllegalStateException( "Could not load ECDSA algorithm. Is bouncycastle on the classpath?"); } try { signature.initSign(privateKey); } catch (InvalidKeyException e) { throw new IllegalStateException("Private key not an ECDSA key."); } try { signature.update(payload); return signature.sign(); } catch (SignatureException e) { throw new IllegalStateException("Could not sign payload.", e); } } @Inject ECDSA256Signer(SignerConfig config); byte[] sign(byte[] payload); }
@Test public void signedCanBeVerified() { byte[] payload = "highlysensitiveinformation".getBytes(StandardCharsets.UTF_8); byte[] signature = signer.sign(payload); assertThat(verifier.verify(payload, signature)).isTrue(); }
ArmeriaSdkHttpClient implements SdkAsyncHttpClient { @Override public CompletableFuture<Void> execute(AsyncExecuteRequest executeRequest) { SdkHttpRequest httpRequest = executeRequest.request(); SdkAsyncHttpResponseHandler handler = executeRequest.responseHandler(); RequestHeadersBuilder headersBuilder = RequestHeaders.builder(convert(httpRequest.method()), httpRequest.getUri().toString()); executeRequest .requestContentPublisher() .contentLength() .ifPresent( contentLength -> headersBuilder.add(HttpHeaderNames.CONTENT_LENGTH, contentLength.toString())); for (Map.Entry<String, List<String>> header : httpRequest.headers().entrySet()) { headersBuilder.add(header.getKey(), header.getValue()); } Publisher<HttpData> requestStream = delegate -> executeRequest .requestContentPublisher() .subscribe(new SdkToHttpDataSubscriber(delegate)); HttpRequest request = HttpRequest.of(headersBuilder.build(), requestStream); HttpResponse response = client.execute(request); response.subscribe(new ResponseSubscriber(handler)); CompletableFuture<Void> completionFuture = response.whenComplete(); completionFuture.whenComplete( (unused, t) -> { if (t != null) { handler.onError(t); } }); return completionFuture; } ArmeriaSdkHttpClient(WebClient client); @Override CompletableFuture<Void> execute(AsyncExecuteRequest executeRequest); @Override String clientName(); @Override void close(); }
@Test void converts_success() { StreamMessage<ByteBuffer> requestStream = StreamMessage.of( ByteBuffer.wrap("meow".getBytes(StandardCharsets.UTF_8)), ByteBuffer.wrap("woof".getBytes(StandardCharsets.UTF_8))); AtomicReference<SdkHttpResponse> responseHeaders = new AtomicReference<>(); AtomicReference<Throwable> responseError = new AtomicReference<>(); AtomicReference<Throwable> responseSubscriberError = new AtomicReference<>(); AtomicBoolean responseComplete = new AtomicBoolean(); List<ByteBuffer> responsePayloads = new ArrayList<>(); AsyncExecuteRequest request = AsyncExecuteRequest.builder() .request( SdkHttpRequest.builder() .protocol("https") .method(SdkHttpMethod.POST) .host("github.com") .appendHeader("X-Animals", "cat") .appendHeader("X-Animals", "dog") .appendHeader("Content-Type", "application/json") .encodedPath("/foo") .appendRawQueryParameter("bar", "baz") .build()) .responseHandler( new SdkAsyncHttpResponseHandler() { @Override public void onHeaders(SdkHttpResponse headers) { responseHeaders.set(headers); } @Override public void onStream(Publisher<ByteBuffer> stream) { stream.subscribe( new Subscriber<ByteBuffer>() { @Override public void onSubscribe(Subscription s) { s.request(Long.MAX_VALUE); } @Override public void onNext(ByteBuffer byteBuffer) { responsePayloads.add(byteBuffer); } @Override public void onError(Throwable t) { responseSubscriberError.set(t); } @Override public void onComplete() { responseComplete.set(true); } }); } @Override public void onError(Throwable error) { responseError.set(error); } }) .requestContentPublisher( new SdkHttpContentPublisher() { @Override public Optional<Long> contentLength() { return Optional.of((long) ("body1" + "body2").length()); } @Override public void subscribe(Subscriber<? super ByteBuffer> s) { requestStream.subscribe(s); } }) .fullDuplex(false) .build(); AtomicReference<AggregatedHttpRequest> aggregatedRequest = new AtomicReference<>(); when(webClient.execute(any(HttpRequest.class))) .thenAnswer( (Answer<HttpResponse>) invocation -> { HttpRequest httpRequest = invocation.getArgument(0); aggregatedRequest.set(httpRequest.aggregate().join()); return HttpResponse.of( ResponseHeaders.of( HttpStatus.OK, HttpHeaderNames.CONTENT_TYPE, "application/json", HttpHeaderNames.of("X-Countries"), "Japan", HttpHeaderNames.of("X-Countries"), "US"), HttpData.ofUtf8("purr"), HttpData.ofUtf8("growl")); }); CompletableFuture<Void> responseFuture = client.execute(request); assertThat(responseFuture.join()).isNull(); assertThat(responseHeaders.get()) .satisfies( headers -> { assertThat(headers.statusCode()).isEqualTo(HttpStatus.OK.code()); assertThat(headers.statusText()).hasValue(HttpStatus.OK.reasonPhrase()); assertThat(headers.headers()) .containsEntry("content-type", ImmutableList.of("application/json")) .containsEntry("x-countries", ImmutableList.of("Japan", "US")); }); assertThat(responsePayloads) .extracting(buf -> Unpooled.wrappedBuffer(buf).toString(StandardCharsets.UTF_8)) .containsExactly("purr", "growl"); assertThat(responseError.get()).isNull(); assertThat(responseSubscriberError.get()).isNull(); }
ArmeriaSdkHttpClient implements SdkAsyncHttpClient { @Override public String clientName() { return "ArmeriaAsync"; } ArmeriaSdkHttpClient(WebClient client); @Override CompletableFuture<Void> execute(AsyncExecuteRequest executeRequest); @Override String clientName(); @Override void close(); }
@Test void clientName() { assertThat(client.clientName()).isEqualTo("ArmeriaAsync"); }
ServiceSettingsImpl { public void addSyncRoot(final File syncRoot, Long expectedSyncTime) throws IllegalStateException { logger.debug("addSyncRoot(): syncRoot = {}", syncRoot); final Map<String, Object> props = new Hashtable<String, Object>(); props.put(ServiceSettingsConsumerImpl.KEY_ACTION, ServiceSettingsConsumerImpl.ACTION_ADD); props.put(ServiceSettingsConsumerImpl.KEY_SYNC_ROOT, syncRoot); if (expectedSyncTime != null) { props.put(ServiceSettingsConsumerImpl.KEY_EXPECTED_SYNC_TIME, expectedSyncTime); } jobManager.addJob(ServiceSettingsConsumerImpl.TOPIC_NAME, props); } void addSyncRoot(final File syncRoot, Long expectedSyncTime); void removeSyncRoot(final File syncRoot); }
@Test public void testAddSyncRoot() { this.props.put(KEY_ACTION, ACTION_ADD); this.props.put(KEY_SYNC_ROOT, new File("/virtual/root")); this.props.put(KEY_EXPECTED_SYNC_TIME, 4000l); this.serviceSettings.addSyncRoot(new File("/virtual/root"), 4000l); verify(this.jobManager, times(1)).addJob(TOPIC_NAME, this.props); } @Test public void testAddSyncRootNoSyncOnce() { this.props.put(KEY_ACTION, ACTION_ADD); this.props.put(KEY_SYNC_ROOT, new File("/virtual/root")); this.props.remove(KEY_EXPECTED_SYNC_TIME); this.serviceSettings.addSyncRoot(new File("/virtual/root"), null); verify(this.jobManager, times(1)).addJob(TOPIC_NAME, this.props); }
InitialRegistrationImpl { @Activate protected void activate(final Map<String, Object> props) throws ServiceException { logger.debug("activate(): props = {}", props); this.filterRoots = PropertiesUtil.toStringArray(props.get(PROP_FILTER_ROOTS), null); if (this.filterRoots == null) { throw new ServiceException(PROP_FILTER_ROOTS + " is mandatory!"); } final String localDirValue = StringUtils.trim(PropertiesUtil.toString(props.get(PROP_LOCAL_PATH), null)); if (localDirValue == null) { throw new ServiceException(PROP_LOCAL_PATH + " is mandatory!"); } this.localDir = new File(localDirValue); this.overwriteConfigFiles = PropertiesUtil.toBoolean(props.get(PROP_OVERWRITE_CONFIG_FILES), DEFAULT_OVERWRITE_CONFIG_FILES); this.syncOnceType = PropertiesUtil.toString(props.get(PROP_SYNC_ONCE_TYPE), SYNC_ONCE_DISABLED); generateFiles(); Long expectedSyncOnceTime = null; if (this.willSyncOnce) { expectedSyncOnceTime = PropertiesUtil.toLong(props.get(PROP_SYNC_ONCE_EXPECTED_TIME), DEFAULT_SYNC_ONCE_EXPECTED_TIME); } this.serviceSettings.addSyncRoot(this.localDir, expectedSyncOnceTime); } }
@Test public void testActivateDirWithIgnorableContentOverwrite() throws URISyntaxException, IOException { assertEquals(0, this.baseDir.list().length); createTempFiles(".vlt-sync.log"); this.props.put(InitialRegistrationImpl.PROP_OVERWRITE_CONFIG_FILES, true); this.initialRegistration.activate(this.props); FileAssert.assertEquals(getResource("data1-config.properties"), this.generatedConfigFile); FileAssert.assertEquals(getResource("data1-filter.xml"), this.generatedFilterFile); verify(this.serviceSettings, times(1)).addSyncRoot(this.baseDir, 3000l); } @Test public void testActivateDirWithContents() throws IOException, URISyntaxException { assertEquals(0, this.baseDir.list().length); createTempFiles("readme.txt", "LICENSE"); this.initialRegistration.activate(this.props); FileAssert.assertEquals(getResource("data2-config.properties"), this.generatedConfigFile); FileAssert.assertEquals(getResource("data1-filter.xml"), this.generatedFilterFile); verify(this.serviceSettings, times(1)).addSyncRoot(this.baseDir, 3000l); } @Test public void testActivateDirWithContentsDisabled() throws IOException, URISyntaxException { assertEquals(0, this.baseDir.list().length); createTempFiles("readme.txt", "LICENSE"); this.props.remove(InitialRegistrationImpl.PROP_SYNC_ONCE_TYPE); this.initialRegistration.activate(this.props); FileAssert.assertEquals(getResource("data3-config.properties"), this.generatedConfigFile); FileAssert.assertEquals(getResource("data1-filter.xml"), this.generatedFilterFile); verify(this.serviceSettings, times(1)).addSyncRoot(this.baseDir, 3000l); } @Test public void testActivateDirWithContentsJcr2Fs() throws IOException, URISyntaxException { assertEquals(0, this.baseDir.list().length); createTempFiles("readme.txt", "LICENSE"); this.props.put(InitialRegistrationImpl.PROP_SYNC_ONCE_TYPE, InitialRegistrationImpl.SYNC_ONCE_JCR2FS); this.initialRegistration.activate(this.props); FileAssert.assertEquals(getResource("data1-config.properties"), this.generatedConfigFile); FileAssert.assertEquals(getResource("data1-filter.xml"), this.generatedFilterFile); verify(this.serviceSettings, times(1)).addSyncRoot(this.baseDir, 3000l); } @Test public void testActivatePropertyFileExists() throws IOException, URISyntaxException { assertEquals(0, this.baseDir.list().length); createTempFiles(SYNC_CONFIG_FN); this.initialRegistration.activate(this.props); FileAssert.assertEquals(getResource("empty-config.properties"), this.generatedConfigFile); FileAssert.assertEquals(getResource("data1-filter.xml"), this.generatedFilterFile); verify(this.serviceSettings, times(1)).addSyncRoot(this.baseDir, null); } @Test public void testActivatePropertyFileExistsNoSyncOnce() throws IOException, URISyntaxException { assertEquals(0, this.baseDir.list().length); FileUtils.copyFile(getResource("data3-config.properties"), this.generatedConfigFile); this.initialRegistration.activate(this.props); FileAssert.assertEquals(getResource("data3-config.properties"), this.generatedConfigFile); FileAssert.assertEquals(getResource("data1-filter.xml"), this.generatedFilterFile); verify(this.serviceSettings, times(1)).addSyncRoot(this.baseDir, null); } @Test public void testActivatePropertyFileExistsOverwrite() throws IOException, URISyntaxException { assertEquals(0, this.baseDir.list().length); createTempFiles(SYNC_CONFIG_FN); this.props.put(InitialRegistrationImpl.PROP_OVERWRITE_CONFIG_FILES, true); this.initialRegistration.activate(this.props); FileAssert.assertEquals(getResource("data1-config.properties"), this.generatedConfigFile); FileAssert.assertEquals(getResource("data1-filter.xml"), this.generatedFilterFile); verify(this.serviceSettings, times(1)).addSyncRoot(this.baseDir, 3000l); } @Test public void testActivatePropertyFileExistsOverwriteDisabled() throws IOException, URISyntaxException { assertEquals(0, this.baseDir.list().length); createTempFiles(SYNC_CONFIG_FN); this.props.remove(InitialRegistrationImpl.PROP_SYNC_ONCE_TYPE); this.props.put(InitialRegistrationImpl.PROP_OVERWRITE_CONFIG_FILES, true); this.initialRegistration.activate(this.props); FileAssert.assertEquals(getResource("data3-config.properties"), this.generatedConfigFile); FileAssert.assertEquals(getResource("data1-filter.xml"), this.generatedFilterFile); verify(this.serviceSettings, times(1)).addSyncRoot(this.baseDir, 3000l); } @Test public void testActivatePropertyFileExistsDirWithContentsOverwrite() throws IOException, URISyntaxException { assertEquals(0, this.baseDir.list().length); createTempFiles("README.md", SYNC_CONFIG_FN); this.props.put(InitialRegistrationImpl.PROP_OVERWRITE_CONFIG_FILES, true); this.props.put(InitialRegistrationImpl.PROP_SYNC_ONCE_EXPECTED_TIME, 3001l); this.initialRegistration.activate(this.props); FileAssert.assertEquals(getResource("data2-config.properties"), this.generatedConfigFile); FileAssert.assertEquals(getResource("data1-filter.xml"), this.generatedFilterFile); verify(this.serviceSettings, times(1)).addSyncRoot(this.baseDir, 3001l); } @Test public void testActivateFilterFileExists() throws IOException, URISyntaxException { assertEquals(0, this.baseDir.list().length); createTempFiles(SYNC_FILTER_FN); this.initialRegistration.activate(this.props); FileAssert.assertEquals(getResource("data1-config.properties"), this.generatedConfigFile); FileAssert.assertEquals(getResource("empty-filter.xml"), this.generatedFilterFile); verify(this.serviceSettings, times(1)).addSyncRoot(this.baseDir, 3000l); } @Test public void testActivateFilterFileExistsOverwrite() throws IOException, URISyntaxException { assertEquals(0, this.baseDir.list().length); createTempFiles(SYNC_FILTER_FN); this.props.put(InitialRegistrationImpl.PROP_OVERWRITE_CONFIG_FILES, true); this.initialRegistration.activate(this.props); FileAssert.assertEquals(getResource("data1-config.properties"), this.generatedConfigFile); FileAssert.assertEquals(getResource("data1-filter.xml"), this.generatedFilterFile); verify(this.serviceSettings, times(1)).addSyncRoot(this.baseDir, 3000l); } @Test public void testActivateDefaultFilterFileExists() throws IOException, URISyntaxException { assertEquals(0, this.baseDir.list().length); createTempFiles(DEFAULT_FILTER_FN); this.initialRegistration.activate(this.props); FileAssert.assertEquals(getResource("data1-config.properties"), this.generatedConfigFile); assertEquals(false, this.generatedFilterFile.exists()); verify(this.serviceSettings, times(1)).addSyncRoot(this.baseDir, 3000l); } @Test public void testActivateDefaultFilterFileExistsOverwrite() throws IOException, URISyntaxException { assertEquals(0, this.baseDir.list().length); createTempFiles(DEFAULT_FILTER_FN); this.props.put(InitialRegistrationImpl.PROP_OVERWRITE_CONFIG_FILES, true); this.initialRegistration.activate(this.props); FileAssert.assertEquals(getResource("data1-config.properties"), this.generatedConfigFile); assertEquals(false, this.generatedFilterFile.exists()); verify(this.serviceSettings, times(1)).addSyncRoot(this.baseDir, 3000l); } @Test public void testActivateMissingProperties() { expectedEx.expect(ServiceException.class); expectedEx.expectMessage(" is mandatory!"); this.initialRegistration.activate(new LinkedHashMap<String, Object>()); } @Test public void testActivateEmptyDir() throws URISyntaxException { this.baseDir.delete(); assertEquals(false, this.baseDir.exists()); this.initialRegistration.activate(this.props); FileAssert.assertEquals(getResource("data1-config.properties"), this.generatedConfigFile); FileAssert.assertEquals(getResource("data1-filter.xml"), this.generatedFilterFile); verify(this.serviceSettings, times(1)).addSyncRoot(this.baseDir, 3000l); } @Test public void testActivateEmptyDirDisabled1() throws URISyntaxException { this.baseDir.delete(); assertEquals(false, this.baseDir.exists()); this.props.remove(InitialRegistrationImpl.PROP_SYNC_ONCE_TYPE); this.initialRegistration.activate(this.props); FileAssert.assertEquals(getResource("data3-config.properties"), this.generatedConfigFile); FileAssert.assertEquals(getResource("data1-filter.xml"), this.generatedFilterFile); verify(this.serviceSettings, times(1)).addSyncRoot(this.baseDir, 3000l); } @Test public void testActivateEmptyDirDisabled2() throws URISyntaxException { this.baseDir.delete(); assertEquals(false, this.baseDir.exists()); this.props.put(InitialRegistrationImpl.PROP_SYNC_ONCE_TYPE, InitialRegistrationImpl.SYNC_ONCE_DISABLED); this.initialRegistration.activate(this.props); FileAssert.assertEquals(getResource("data3-config.properties"), this.generatedConfigFile); FileAssert.assertEquals(getResource("data1-filter.xml"), this.generatedFilterFile); verify(this.serviceSettings, times(1)).addSyncRoot(this.baseDir, 3000l); } @Test public void testActivateTrimPathProperty() throws URISyntaxException { this.baseDir.delete(); assertEquals(false, this.baseDir.exists()); this.props.put(InitialRegistrationImpl.PROP_LOCAL_PATH, " " + this.baseDir.getAbsolutePath() + " "); this.initialRegistration.activate(this.props); FileAssert.assertEquals(getResource("data1-config.properties"), this.generatedConfigFile); FileAssert.assertEquals(getResource("data1-filter.xml"), this.generatedFilterFile); verify(this.serviceSettings, times(1)).addSyncRoot(this.baseDir, 3000l); } @Test public void testActivateDirWithIgnorableContent() throws URISyntaxException, IOException { assertEquals(0, this.baseDir.list().length); createTempFiles(".vlt-sync.log"); this.initialRegistration.activate(this.props); FileAssert.assertEquals(getResource("data1-config.properties"), this.generatedConfigFile); FileAssert.assertEquals(getResource("data1-filter.xml"), this.generatedFilterFile); verify(this.serviceSettings, times(1)).addSyncRoot(this.baseDir, 3000l); } @Test public void testActivateDirWithIgnorableContentDisabled() throws URISyntaxException, IOException { assertEquals(0, this.baseDir.list().length); createTempFiles(".vlt-sync.log"); this.props.remove(InitialRegistrationImpl.PROP_SYNC_ONCE_TYPE); this.initialRegistration.activate(this.props); FileAssert.assertEquals(getResource("data3-config.properties"), this.generatedConfigFile); FileAssert.assertEquals(getResource("data1-filter.xml"), this.generatedFilterFile); verify(this.serviceSettings, times(1)).addSyncRoot(this.baseDir, 3000l); }
InitialRegistrationImpl { @Deactivate protected void deactivate() { logger.debug("deactivate()"); if (this.localDir != null) { this.serviceSettings.removeSyncRoot(this.localDir); } this.filterRoots = null; this.localDir = null; this.overwriteConfigFiles = null; this.syncOnceType = null; this.willSyncOnce = null; } }
@Test public void testDeactivate() { assertEquals(0, this.baseDir.list().length); this.initialRegistration.activate(this.props); this.initialRegistration.deactivate(); verify(this.serviceSettings, times(1)).removeSyncRoot(this.baseDir); }
ServiceSettingsConsumerImpl implements JobConsumer { protected void removeSyncRoot(final File syncRoot) throws IllegalStateException { logger.debug("removeSyncRoot(): syncRoot = {}", syncRoot); final Configuration configuration = getConfiguration(); final Dictionary<String, Object> properties = getProperties(configuration); final Set<String> syncRoots = getSyncRoots(properties); syncRoots.remove(syncRoot.getAbsolutePath()); properties.put(PROP_SYNCROOTS, syncRoots.toArray(new String[syncRoots.size()])); if (syncRoots.size() == 0) { disableSync(properties); } update(configuration, properties, null); } JobResult process(Job job); }
@Test public void testRemoveSyncRoot() throws IOException { assertNull(this.dictionary.get(PROP_ENABLED)); this.dictionary.put(PROP_SYNCROOTS, new String[] { "/virtual/old1", "/virtual/old2" }); this.serviceSettingsConsumer.removeSyncRoot(new File("/virtual/old1")); assertNull(this.dictionary.get(PROP_ENABLED)); assertArrayEquals(new String[] { "/virtual/old2" }, (String[]) this.dictionary.get(PROP_SYNCROOTS)); verify(this.configuration, times(1)).update(this.dictionary); }
ServiceSettingsImpl { public void removeSyncRoot(final File syncRoot) throws IllegalStateException { logger.debug("removeSyncRoot(): syncRoot = {}", syncRoot); final Map<String, Object> props = new Hashtable<String, Object>(); props.put(ServiceSettingsConsumerImpl.KEY_ACTION, ServiceSettingsConsumerImpl.ACTION_REMOVE); props.put(ServiceSettingsConsumerImpl.KEY_SYNC_ROOT, syncRoot); jobManager.addJob(ServiceSettingsConsumerImpl.TOPIC_NAME, props); } void addSyncRoot(final File syncRoot, Long expectedSyncTime); void removeSyncRoot(final File syncRoot); }
@Test public void testRemoveSyncRoot() { this.props.put(KEY_ACTION, ACTION_REMOVE); this.props.put(KEY_SYNC_ROOT, new File("/virtual/root")); this.serviceSettings.removeSyncRoot(new File("/virtual/root")); verify(this.jobManager, times(1)).addJob(TOPIC_NAME, this.props); }
ReflectTool { public static <T> String tryGetGeneric(T t) { ParameterizedType pt = null; Type[] types = t.getClass().getGenericInterfaces(); if (types.length != 0 && types[0] instanceof ParameterizedType) { pt = (ParameterizedType) types[0]; } else { Type type = t.getClass().getGenericSuperclass(); if (type instanceof ParameterizedType) { pt = (ParameterizedType) type; } } if (pt == null) { return null; } Type[] actual= pt.getActualTypeArguments(); String unsafe = actual[0].toString(); String genericString; if (unsafe.contains(",")) { genericString = unsafe; } else { String[] elms = unsafe.split(" "); genericString = elms.length <= 1 ? unsafe : elms[1]; } return genericString.length() < 4 ? null : genericString; } static Context getApplication(); static String tryGetGeneric(T t); @SuppressWarnings("all") static String getFieldTypeWithGeneric(Field f); static boolean debugable(); }
@Test public void checkMap() { String cls; Map<String, Object> map = new HashMap<>(); cls = ReflectTool.tryGetGeneric(map); assertEquals(cls, null); Mark<Map<String,Object>> mark = new Mark<Map<String, Object>>() { }; cls = ReflectTool.tryGetGeneric(mark); assertEquals(cls, "java.util.Map<java.lang.String, java.lang.Object>"); } @Test public void checkList() { String cls; List<String> list = new ArrayList<>(); cls = ReflectTool.tryGetGeneric(list); assertEquals(cls, null); Mark<List<String>> mark = new Mark<List<String>>() { }; cls = ReflectTool.tryGetGeneric(mark); assertEquals(cls, "java.util.List<java.lang.String>"); IMark<List<String>> iMark = new IMark<List<String>>() { }; cls = ReflectTool.tryGetGeneric(iMark); assertEquals(cls, "java.util.List<java.lang.String>"); MarkImpl<List<String>> markImpl = new MarkImpl<List<String>>() { }; cls = ReflectTool.tryGetGeneric(markImpl); assertEquals(cls, "java.util.List<java.lang.String>"); } @Test public void checkCustomObj() { String cls; Object o = new Object(); cls = ReflectTool.tryGetGeneric(o); assertEquals(cls, null); MarkImpl<A> markA = new MarkImpl<A>() { }; cls = ReflectTool.tryGetGeneric(markA); assertEquals(cls, A.class.getName()); MarkImpl<B> markB = new MarkImpl<B>() { }; cls = ReflectTool.tryGetGeneric(markB); assertEquals(cls, B.class.getName()); MarkImpl<C> markC = new MarkImpl<C>() { }; cls = ReflectTool.tryGetGeneric(markC); assertEquals(cls, C.class.getName()); MarkImpl<D> markD = new MarkImpl<D>() { }; cls = ReflectTool.tryGetGeneric(markD); assertEquals(cls, D.class.getName()); }
RetrofitApiClient { public POICategories getPOICategories() throws IOException { Response<PoiTypesDto> response = v2Api.getPOICategories().execute(); return response.body().toPOICategories(context); } @SuppressWarnings("deprecation") RetrofitApiClient(Builder builder); String getJourneyJson(final String plan, final String itineraryPoints, final String leaving, final String arriving, final int speed); String retrievePreviousJourneyJson(final String plan, final long itineraryId); Blog getBlogEntries(); POICategories getPOICategories(); List<POI> getPOIs(final String type, final double lonW, final double latS, final double lonE, final double latN); List<POI> getPOIs(final String type, final double lon, final double lat, final int radius); GeoPlaces geoCoder(final String search, final double lonW, final double latS, final double lonE, final double latN); PhotomapCategories getPhotomapCategories(); Photos getPhotos(final double lonW, final double latS, final double lonE, final double latN); Photos getPhoto(final long photoId); UserJourneys getUserJourneys(final String username); Result register(final String username, final String password, final String name, final String email); Signin.Result authenticate(final String identifier, final String password); Result sendFeedback(final int itinerary, final String comments, final String name, final String email); Upload.Result uploadPhoto(final String username, final String password, final double lon, final double lat, final long dateTime, final String category, final String metaCat, final String caption, final String filename); }
@Test public void testGetPoiCategories() throws Exception { stubFor(get(urlPathEqualTo("/v2/pois.types")) .willReturn(aResponse() .withStatus(200) .withHeader("Content-Type", "application/json") .withHeader("Cache-Control", "public, max-age=604800") .withBodyFile("pois-types.json"))); when(testResources.getResourcePackageName(R.drawable.poi_bedsforcyclists)).thenReturn("drawable-xxhdpi"); when(testResources.getDrawable(anyInt(), eq(null))).thenReturn(mock(Drawable.class)); POICategories poiCategories = apiClient.getPOICategories(); for (int ii = 0; ii < 5; ii++) { apiClient.getPOICategories(); } verify(getRequestedFor(urlPathEqualTo("/v2/pois.types")) .withQueryParam("key", equalTo("myApiKey"))); assertThat(poiCategories.count()).isEqualTo(52); POICategory category = poiCategories.get(37); assertThat(category.getName()).isEqualTo("Supermarkets"); assertThat(category.getIcon()).isNotNull(); List<LoggedRequest> requests = findAll(getRequestedFor(urlPathEqualTo("/v2/pois.types"))); assertThat(requests).hasSize(1); }
RetrofitApiClient { public PhotomapCategories getPhotomapCategories() throws IOException { Response<PhotomapCategoriesDto> response = v2Api.getPhotomapCategories().execute(); return response.body().toPhotomapCategories(); } @SuppressWarnings("deprecation") RetrofitApiClient(Builder builder); String getJourneyJson(final String plan, final String itineraryPoints, final String leaving, final String arriving, final int speed); String retrievePreviousJourneyJson(final String plan, final long itineraryId); Blog getBlogEntries(); POICategories getPOICategories(); List<POI> getPOIs(final String type, final double lonW, final double latS, final double lonE, final double latN); List<POI> getPOIs(final String type, final double lon, final double lat, final int radius); GeoPlaces geoCoder(final String search, final double lonW, final double latS, final double lonE, final double latN); PhotomapCategories getPhotomapCategories(); Photos getPhotos(final double lonW, final double latS, final double lonE, final double latN); Photos getPhoto(final long photoId); UserJourneys getUserJourneys(final String username); Result register(final String username, final String password, final String name, final String email); Signin.Result authenticate(final String identifier, final String password); Result sendFeedback(final int itinerary, final String comments, final String name, final String email); Upload.Result uploadPhoto(final String username, final String password, final double lon, final double lat, final long dateTime, final String category, final String metaCat, final String caption, final String filename); }
@Test public void testGetPhotomapCategories() throws Exception { stubFor(get(urlPathEqualTo("/v2/photomap.categories")) .willReturn(aResponse() .withStatus(200) .withHeader("Content-Type", "application/json") .withHeader("Cache-Control", "public, max-age=1209600") .withBodyFile("photomap-categories.json"))); PhotomapCategories categories = apiClient.getPhotomapCategories(); for (int ii = 0; ii < 5; ii++) { apiClient.getPhotomapCategories(); } verify(getRequestedFor(urlPathEqualTo("/v2/photomap.categories")) .withQueryParam("key", equalTo("myApiKey"))); assertThat(categories.categories().size()).isEqualTo(18); assertThat(categories.metaCategories().size()).isEqualTo(5); PhotomapCategory category = categories.categories().get(12); assertThat(category.getTag()).isEqualTo("destinations"); assertThat(category.getName()).isEqualTo("Destination"); assertThat(category.getDescription()).isEqualTo("A place where you might want to visit."); PhotomapCategory metaCategory = categories.metaCategories().get(3); assertThat(metaCategory.getTag()).isEqualTo("any"); assertThat(metaCategory.getName()).isEqualTo("Misc"); assertThat(metaCategory.getDescription()).isEqualTo("Non-specific"); List<LoggedRequest> requests = findAll(getRequestedFor(urlPathEqualTo("/v2/photomap.categories"))); assertThat(requests).hasSize(1); }
RetrofitApiClient { public Upload.Result uploadPhoto(final String username, final String password, final double lon, final double lat, final long dateTime, final String category, final String metaCat, final String caption, final String filename) throws IOException { MultipartBody.Part filePart = null; if (filename != null) { File file = new File(filename); RequestBody fileBody = RequestBody.create(MediaType.parse("multipart/form-data"), file); filePart = MultipartBody.Part.createFormData("mediaupload", file.getName(), fileBody); } RequestBody usernamePart = RequestBody.create(MediaType.parse("text/plain"), username); RequestBody passwordPart = RequestBody.create(MediaType.parse("text/plain"), password); RequestBody categoryPart = RequestBody.create(MediaType.parse("text/plain"), category); RequestBody metaCatPart = RequestBody.create(MediaType.parse("text/plain"), metaCat); RequestBody captionPart = RequestBody.create(MediaType.parse("text/plain"), caption); Response<UploadPhotoResponseDto> response = v2Api.uploadPhoto(usernamePart, passwordPart, lon, lat, dateTime, categoryPart, metaCatPart, captionPart, filePart).execute(); return response.body().toUploadResult(); } @SuppressWarnings("deprecation") RetrofitApiClient(Builder builder); String getJourneyJson(final String plan, final String itineraryPoints, final String leaving, final String arriving, final int speed); String retrievePreviousJourneyJson(final String plan, final long itineraryId); Blog getBlogEntries(); POICategories getPOICategories(); List<POI> getPOIs(final String type, final double lonW, final double latS, final double lonE, final double latN); List<POI> getPOIs(final String type, final double lon, final double lat, final int radius); GeoPlaces geoCoder(final String search, final double lonW, final double latS, final double lonE, final double latN); PhotomapCategories getPhotomapCategories(); Photos getPhotos(final double lonW, final double latS, final double lonE, final double latN); Photos getPhoto(final long photoId); UserJourneys getUserJourneys(final String username); Result register(final String username, final String password, final String name, final String email); Signin.Result authenticate(final String identifier, final String password); Result sendFeedback(final int itinerary, final String comments, final String name, final String email); Upload.Result uploadPhoto(final String username, final String password, final double lon, final double lat, final long dateTime, final String category, final String metaCat, final String caption, final String filename); }
@Test public void testUploadPhotoReturnsOk() throws Exception { stubFor(post(urlPathEqualTo("/v2/photomap.add")) .willReturn(aResponse() .withStatus(200) .withHeader("Content-Type", "application/json") .withBodyFile("upload-ok.json"))); Upload.Result result = apiClient.uploadPhoto("arnold", "cyberdyne101", -0.5, 53, 12345678, "scifi", "evilrobots", "The Cyberdyne Model 101", null); verify(postRequestedFor(urlPathEqualTo("/v2/photomap.add")) .withHeader("Content-Type", matching("multipart/form-data; boundary=.*")) .withRequestBody(matching(".*username.*arnold.*password.*cyberdyne101.*longitude.*-0.5.*latitude.*53.*datetime.*12345678.*category.*scifi.*metacategory.*evilrobots.*caption.*The Cyberdyne Model 101.*")) .withQueryParam("key", equalTo("myApiKey"))); assertThat(result.ok()).isTrue(); assertThat(result.url()).isEqualTo("https: }
RetrofitApiClient { public String getJourneyJson(final String plan, final String itineraryPoints, final String leaving, final String arriving, final int speed) throws IOException { Response<String> response = v1Api.getJourneyJson(plan, itineraryPoints, leaving, arriving, speed).execute(); return JourneyStringTransformerKt.fromV1ApiJson(response.body()); } @SuppressWarnings("deprecation") RetrofitApiClient(Builder builder); String getJourneyJson(final String plan, final String itineraryPoints, final String leaving, final String arriving, final int speed); String retrievePreviousJourneyJson(final String plan, final long itineraryId); Blog getBlogEntries(); POICategories getPOICategories(); List<POI> getPOIs(final String type, final double lonW, final double latS, final double lonE, final double latN); List<POI> getPOIs(final String type, final double lon, final double lat, final int radius); GeoPlaces geoCoder(final String search, final double lonW, final double latS, final double lonE, final double latN); PhotomapCategories getPhotomapCategories(); Photos getPhotos(final double lonW, final double latS, final double lonE, final double latN); Photos getPhoto(final long photoId); UserJourneys getUserJourneys(final String username); Result register(final String username, final String password, final String name, final String email); Signin.Result authenticate(final String identifier, final String password); Result sendFeedback(final int itinerary, final String comments, final String name, final String email); Upload.Result uploadPhoto(final String username, final String password, final double lon, final double lat, final long dateTime, final String category, final String metaCat, final String caption, final String filename); }
@Test public void testGetJourneyJson() throws Exception { stubFor(get(urlPathEqualTo("/api/journey.json")) .willReturn(aResponse() .withStatus(200) .withHeader("Content-Type", "text/json") .withBodyFile("journey-v1api.json"))); String journeyJson = apiClient.getJourneyJson("balanced", "mySetOfItineraryPoints", "2016-07-03 07:51:12", null, 24); verify(getRequestedFor(urlPathEqualTo("/api/journey.json")) .withQueryParam("plan", equalTo("balanced")) .withQueryParam("itinerarypoints", equalTo("mySetOfItineraryPoints")) .withQueryParam("leaving", equalTo("2016-07-03 07:51:12")) .withQueryParam("speed", equalTo("24")) .withQueryParam("key", equalTo("myApiKey"))); assertThat(journeyJson).isNotNull(); assertThat(journeyJson).contains("{"); }
RetrofitApiClient { public Blog getBlogEntries() throws IOException { Response<BlogFeedDto> response = blogApi.getBlogEntries().execute(); return response.body().toBlog(); } @SuppressWarnings("deprecation") RetrofitApiClient(Builder builder); String getJourneyJson(final String plan, final String itineraryPoints, final String leaving, final String arriving, final int speed); String retrievePreviousJourneyJson(final String plan, final long itineraryId); Blog getBlogEntries(); POICategories getPOICategories(); List<POI> getPOIs(final String type, final double lonW, final double latS, final double lonE, final double latN); List<POI> getPOIs(final String type, final double lon, final double lat, final int radius); GeoPlaces geoCoder(final String search, final double lonW, final double latS, final double lonE, final double latN); PhotomapCategories getPhotomapCategories(); Photos getPhotos(final double lonW, final double latS, final double lonE, final double latN); Photos getPhoto(final long photoId); UserJourneys getUserJourneys(final String username); Result register(final String username, final String password, final String name, final String email); Signin.Result authenticate(final String identifier, final String password); Result sendFeedback(final int itinerary, final String comments, final String name, final String email); Upload.Result uploadPhoto(final String username, final String password, final double lon, final double lat, final long dateTime, final String category, final String metaCat, final String caption, final String filename); }
@Test public void testGetBlogEntries() throws Exception { stubFor(get(urlPathEqualTo("/news/feed/")) .willReturn(aResponse() .withStatus(200) .withHeader("Content-Type", "application/rss+xml; charset=UTF-8") .withBodyFile("blogfeed.xml"))); Blog blog = apiClient.getBlogEntries(); for (int ii = 0; ii < 5; ii++) { apiClient.getBlogEntries(); } verify(getRequestedFor(urlPathEqualTo("/news/feed/")) .withQueryParam("key", equalTo("myApiKey"))); assertThat(blog).isNotNull(); assertThat(blog.mostRecentTitle()).isEqualTo("Cyclescape website redesign coming soon"); assertThat(blog.mostRecent()).isEqualTo("Thu, 02 Jan 2020 20:25:56 +0000"); List<LoggedRequest> requests = findAll(getRequestedFor(urlPathEqualTo("/news/feed/")) .withQueryParam("key", equalTo("myApiKey"))); assertThat(requests).hasSize(1); }
RetrofitApiClient { public List<POI> getPOIs(final String type, final double lonW, final double latS, final double lonE, final double latN) throws IOException { String bbox = toBboxString(lonW, latS, lonE, latN); Response<FeatureCollection> response = v2Api.getPOIs(type, bbox).execute(); return PoiFactory.toPoiList(response.body()); } @SuppressWarnings("deprecation") RetrofitApiClient(Builder builder); String getJourneyJson(final String plan, final String itineraryPoints, final String leaving, final String arriving, final int speed); String retrievePreviousJourneyJson(final String plan, final long itineraryId); Blog getBlogEntries(); POICategories getPOICategories(); List<POI> getPOIs(final String type, final double lonW, final double latS, final double lonE, final double latN); List<POI> getPOIs(final String type, final double lon, final double lat, final int radius); GeoPlaces geoCoder(final String search, final double lonW, final double latS, final double lonE, final double latN); PhotomapCategories getPhotomapCategories(); Photos getPhotos(final double lonW, final double latS, final double lonE, final double latN); Photos getPhoto(final long photoId); UserJourneys getUserJourneys(final String username); Result register(final String username, final String password, final String name, final String email); Signin.Result authenticate(final String identifier, final String password); Result sendFeedback(final int itinerary, final String comments, final String name, final String email); Upload.Result uploadPhoto(final String username, final String password, final double lon, final double lat, final long dateTime, final String category, final String metaCat, final String caption, final String filename); }
@Test public void testGetPoisByBbox() throws Exception { stubFor(get(urlPathEqualTo("/v2/pois.locations")) .willReturn(aResponse() .withStatus(200) .withHeader("Content-Type", "application/json") .withBodyFile("pois.json"))); List<POI> pois = apiClient.getPOIs("bikeshops", 0.1, 52.2, 0.2, 52.3); verify(getRequestedFor(urlPathEqualTo("/v2/pois.locations")) .withQueryParam("type", equalTo("bikeshops")) .withQueryParam("bbox", equalTo("0.1,52.2,0.2,52.3")) .withQueryParam("fields", equalTo("id,latitude,longitude,name,notes,osmTags,website")) .withQueryParam("key", equalTo("myApiKey"))); validatePois(pois); } @Test public void testGetPoisByRadius() throws Exception { stubFor(get(urlPathEqualTo("/v2/pois.locations")) .willReturn(aResponse() .withStatus(200) .withHeader("Content-Type", "application/json") .withBodyFile("pois.json"))); List<POI> pois = apiClient.getPOIs("bikeshops", 0.15, 52.25, 100); for (int ii = 0; ii < 5; ii++) { apiClient.getPOIs("bikeshops", 0.15, 52.25, 100); } verify(getRequestedFor(urlPathEqualTo("/v2/pois.locations")) .withQueryParam("type", equalTo("bikeshops")) .withQueryParam("longitude", equalTo("0.15")) .withQueryParam("latitude", equalTo("52.25")) .withQueryParam("radius", equalTo("100")) .withQueryParam("limit", equalTo("150")) .withQueryParam("fields", equalTo("id,latitude,longitude,name,notes,osmTags,website")) .withQueryParam("key", equalTo("myApiKey"))); validatePois(pois); List<LoggedRequest> requests = findAll(getRequestedFor(urlPathEqualTo("/v2/pois.locations"))); assertThat(requests).hasSize(6); }
RetrofitApiClient { public UserJourneys getUserJourneys(final String username) throws IOException { Response<UserJourneysDto> response = v2Api.getUserJourneys(username).execute(); return response.body().toUserJourneys(); } @SuppressWarnings("deprecation") RetrofitApiClient(Builder builder); String getJourneyJson(final String plan, final String itineraryPoints, final String leaving, final String arriving, final int speed); String retrievePreviousJourneyJson(final String plan, final long itineraryId); Blog getBlogEntries(); POICategories getPOICategories(); List<POI> getPOIs(final String type, final double lonW, final double latS, final double lonE, final double latN); List<POI> getPOIs(final String type, final double lon, final double lat, final int radius); GeoPlaces geoCoder(final String search, final double lonW, final double latS, final double lonE, final double latN); PhotomapCategories getPhotomapCategories(); Photos getPhotos(final double lonW, final double latS, final double lonE, final double latN); Photos getPhoto(final long photoId); UserJourneys getUserJourneys(final String username); Result register(final String username, final String password, final String name, final String email); Signin.Result authenticate(final String identifier, final String password); Result sendFeedback(final int itinerary, final String comments, final String name, final String email); Upload.Result uploadPhoto(final String username, final String password, final double lon, final double lat, final long dateTime, final String category, final String metaCat, final String caption, final String filename); }
@Test public void testGetUserJourneys() throws Exception { stubFor(get(urlPathEqualTo("/v2/journeys.user")) .willReturn(aResponse() .withStatus(200) .withHeader("Content-Type", "application/json") .withBodyFile("journeys.json"))); UserJourneys journeys = apiClient.getUserJourneys("socrates"); verify(getRequestedFor(urlPathEqualTo("/v2/journeys.user")) .withQueryParam("username", equalTo("socrates")) .withQueryParam("format", equalTo("flat")) .withQueryParam("datetime", equalTo("friendly")) .withQueryParam("key", equalTo("myApiKey"))); assertThat(journeys.size()).isEqualTo(3); UserJourney journey = journeys.get(2); assertThat(journey.name()).isEqualTo("Hedingham Close to Old Montague Street"); assertThat(journey.id()).isEqualTo(43089395); }
RetrofitApiClient { public Photos getPhotos(final double lonW, final double latS, final double lonE, final double latN) throws IOException { String bbox = toBboxString(lonW, latS, lonE, latN); Response<FeatureCollection> response = v2Api.getPhotos(bbox).execute(); return PhotosFactory.toPhotos(response.body()); } @SuppressWarnings("deprecation") RetrofitApiClient(Builder builder); String getJourneyJson(final String plan, final String itineraryPoints, final String leaving, final String arriving, final int speed); String retrievePreviousJourneyJson(final String plan, final long itineraryId); Blog getBlogEntries(); POICategories getPOICategories(); List<POI> getPOIs(final String type, final double lonW, final double latS, final double lonE, final double latN); List<POI> getPOIs(final String type, final double lon, final double lat, final int radius); GeoPlaces geoCoder(final String search, final double lonW, final double latS, final double lonE, final double latN); PhotomapCategories getPhotomapCategories(); Photos getPhotos(final double lonW, final double latS, final double lonE, final double latN); Photos getPhoto(final long photoId); UserJourneys getUserJourneys(final String username); Result register(final String username, final String password, final String name, final String email); Signin.Result authenticate(final String identifier, final String password); Result sendFeedback(final int itinerary, final String comments, final String name, final String email); Upload.Result uploadPhoto(final String username, final String password, final double lon, final double lat, final long dateTime, final String category, final String metaCat, final String caption, final String filename); }
@Test public void testGetPhotos() throws Exception { stubFor(get(urlPathEqualTo("/v2/photomap.locations")) .willReturn(aResponse() .withStatus(200) .withHeader("Content-Type", "application/json") .withBodyFile("photos.json"))); Photos photos = apiClient.getPhotos(0.1, 52.2, 0.2, 52.3); verify(getRequestedFor(urlPathEqualTo("/v2/photomap.locations")) .withQueryParam("bbox", equalTo("0.1,52.2,0.2,52.3")) .withQueryParam("fields", equalTo("id,caption,datetime,categoryId,metacategoryId,hasVideo,videoFormats,thumbnailUrl,shortlink")) .withQueryParam("thumbnailsize", equalTo("640")) .withQueryParam("limit", equalTo("45")) .withQueryParam("key", equalTo("myApiKey"))); Iterator<Photo> iterator = photos.iterator(); iterator.next(); iterator.next(); iterator.next(); Photo photo4 = iterator.next(); assertThat(iterator.hasNext()).isFalse(); assertThat(photo4.id()).isEqualTo(82169); assertThat(photo4.caption()).isEqualTo("Link from Clerk Maxwell Road to the West Cambridge site"); assertThat(photo4.datetime()).isEqualTo(1466693269L); assertThat(photo4.category()).isEqualTo("cycleways"); assertThat(photo4.metacategory()).isEqualTo("other"); assertThat(photo4.thumbnailUrl()).isEqualTo("https: assertThat(photo4.url()).isEqualTo("https: assertThat(photo4.position()).isEqualTo(new GeoPoint(52.209908, 0.094543)); assertThat(photo4.isPlaceholder()).isFalse(); assertThat(photo4.hasVideos()).isTrue(); List<Video> videos = (List<Video>)photo4.videos(); assertThat(videos.size()).isEqualTo(2); Video video = videos.get(1); assertThat(video.url()).isEqualTo("https: assertThat(video.format()).isEqualTo("flv"); }
RetrofitApiClient { public GeoPlaces geoCoder(final String search, final double lonW, final double latS, final double lonE, final double latN) throws IOException { String bbox = toBboxString(lonW, latS, lonE, latN); Response<FeatureCollection> response = v2Api.geoCoder(search, bbox).execute(); return GeoPlacesFactory.toGeoPlaces(response.body()); } @SuppressWarnings("deprecation") RetrofitApiClient(Builder builder); String getJourneyJson(final String plan, final String itineraryPoints, final String leaving, final String arriving, final int speed); String retrievePreviousJourneyJson(final String plan, final long itineraryId); Blog getBlogEntries(); POICategories getPOICategories(); List<POI> getPOIs(final String type, final double lonW, final double latS, final double lonE, final double latN); List<POI> getPOIs(final String type, final double lon, final double lat, final int radius); GeoPlaces geoCoder(final String search, final double lonW, final double latS, final double lonE, final double latN); PhotomapCategories getPhotomapCategories(); Photos getPhotos(final double lonW, final double latS, final double lonE, final double latN); Photos getPhoto(final long photoId); UserJourneys getUserJourneys(final String username); Result register(final String username, final String password, final String name, final String email); Signin.Result authenticate(final String identifier, final String password); Result sendFeedback(final int itinerary, final String comments, final String name, final String email); Upload.Result uploadPhoto(final String username, final String password, final double lon, final double lat, final long dateTime, final String category, final String metaCat, final String caption, final String filename); }
@Test public void testGeoCoder() throws Exception { stubFor(get(urlPathEqualTo("/v2/geocoder")) .willReturn(aResponse() .withStatus(200) .withHeader("Content-Type", "application/json") .withBodyFile("geocoder.json"))); GeoPlaces geoPlaces = apiClient.geoCoder("High", 0.1, 52.2, 0.2, 52.3); for (int ii = 0; ii < 5; ii++) { apiClient.geoCoder("High", 0.1, 52.2, 0.2, 52.3); } verify(getRequestedFor(urlPathEqualTo("/v2/geocoder")) .withQueryParam("bbox", equalTo("0.1,52.2,0.2,52.3")) .withQueryParam("countrycodes", equalTo("gb,ie")) .withQueryParam("q", equalTo("High")) .withQueryParam("key", equalTo("myApiKey"))); assertThat(geoPlaces.size()).isEqualTo(5); GeoPlace place = geoPlaces.get(1); assertThat(place.name()).isEqualTo("The High"); assertThat(place.near()).isEqualTo("Essex, East of England"); assertThat(place.coord()).isEqualTo(new GeoPoint(51.769678, 0.0939271)); List<LoggedRequest> requests = findAll(getRequestedFor(urlPathEqualTo("/v2/geocoder"))); assertThat(requests).hasSize(6); }