src_fm_fc_ms_ff
stringlengths 43
86.8k
| target
stringlengths 20
276k
|
|---|---|
JPQLJoinSelectSingleStatementBuilder extends JPQLStatementBuilder { @Override public JPQLStatement build() throws ODataJPARuntimeException { jpqlStatement = createStatement(createJPQLQuery()); return jpqlStatement; } JPQLJoinSelectSingleStatementBuilder(final JPQLContextView context); @Override JPQLStatement build(); } | @Test public void testBuild() throws Exception { setUp(getJoinClauseList()); JPQLJoinSelectSingleStatementBuilder jpqlJoinSelectsingleStatementBuilder = new JPQLJoinSelectSingleStatementBuilder(context); try { JPQLStatement jpqlStatement = jpqlJoinSelectsingleStatementBuilder.build(); assertEquals("SELECT gt1 FROM SOHeader soh JOIN soh.soItem soi JOIN soi.material mat WHERE soh.soId = 1 AND soi.shId = soh.soId AND mat.id = 'abc'", jpqlStatement.toString()); } catch (ODataJPARuntimeException e) { fail("Should not have come here"); } }
@Test public void testJoinClauseAsNull() throws Exception { setUp(null); JPQLJoinSelectSingleStatementBuilder jpqlJoinSelectsingleStatementBuilder = new JPQLJoinSelectSingleStatementBuilder(context); try { jpqlJoinSelectsingleStatementBuilder.build(); fail("Should not have come here"); } catch (ODataJPARuntimeException e) { assertTrue(true); } }
@Test public void testJoinClauseListAsEmpty() throws Exception { List<JPAJoinClause> joinClauseList = new ArrayList<JPAJoinClause>(); setUp(joinClauseList); JPQLJoinSelectSingleStatementBuilder jpqlJoinSelectsingleStatementBuilder = new JPQLJoinSelectSingleStatementBuilder(context); try { jpqlJoinSelectsingleStatementBuilder.build(); fail("Should not have come here"); } catch (ODataJPARuntimeException e) { assertTrue(true); } } |
DataContainer { public void reset() { employees.clear(); teams.clear(); rooms.clear(); managers.clear(); buildings.clear(); photos.clear(); employeeId = 0; teamId = 0; roomId = 0; buildingId = 0; photoId = 0; init(); } void init(); Employee createEmployee(); Team createTeam(); Room createRoom(); Manager createManager(); Building createBuilding(); Photo createPhoto(final String type); List<Employee> getEmployees(); List<Team> getTeams(); List<Room> getRooms(); List<Manager> getManagers(); List<Building> getBuildings(); List<Photo> getPhotos(); void reset(); } | @Test public void testReset() { dataContainer.init(); List<Team> data = dataContainer.getTeams(); for (Team team : data) { if (team.getId().equals("2")) { team.setName(NAME); assertEquals(team.getName(), NAME); } } dataContainer.reset(); data = dataContainer.getTeams(); for (Team team2 : data) { if (team2.getId() == "2") { assertEquals(team2.getName(), "Team 2"); assertNotSame(team2.getName(), NAME); } } } |
JPQLJoinSelectSingleContext extends JPQLSelectSingleContext implements JPQLJoinSelectSingleContextView { @Override public List<JPAJoinClause> getJPAJoinClauses() { return jpaJoinClauses; } @Override List<JPAJoinClause> getJPAJoinClauses(); } | @Test public void testGetJPAOuterJoinClauses() throws Exception { setUp(false); JPQLJoinSelectSingleContext joinContext = new JPQLJoinSelectSingleContext(); JPQLJoinSelectSingleContextBuilder joinContextBuilder = joinContext.new JPQLJoinSelectSingleContextBuilder(); try { joinContextBuilder.entityView = entityUriInfo; joinContextBuilder.build(); } catch (ODataJPAModelException e) { fail("Should not come here"); } catch (ODataJPARuntimeException e) { fail("Should not come here"); } List<JPAJoinClause> joinClauses = joinContext.getJPAJoinClauses(); assertNotNull(joinClauses); assertTrue(joinClauses.size() > 0); assertEquals("E1", joinClauses.get(0).getEntityAlias()); assertEquals("SOHeader", joinClauses.get(0).getEntityName()); assertEquals("s_Itema", joinClauses.get(1).getEntityRelationShip()); assertEquals("R1", joinClauses.get(1).getEntityRelationShipAlias()); } |
JPQLSelectSingleStatementBuilder extends JPQLStatementBuilder { @Override public JPQLStatement build() throws ODataJPARuntimeException { jpqlStatement = createStatement(createJPQLQuery()); return jpqlStatement; } JPQLSelectSingleStatementBuilder(final JPQLContextView context); @Override JPQLStatement build(); } | @Test public void testBuildSimpleQuery() throws EdmException, ODataJPARuntimeException { JPQLSelectSingleContext JPQLSelectSingleContextImpl = createSelectContext(); JPQLSelectSingleStatementBuilder = new JPQLSelectSingleStatementBuilder(JPQLSelectSingleContextImpl); assertEquals("SELECT E1 FROM SalesOrderHeader E1 WHERE E1.Field1 = 1", JPQLSelectSingleStatementBuilder.build().toString()); } |
JPAEdmEntityContainer extends JPAEdmBaseViewImpl implements
JPAEdmEntityContainerView { @Override public JPAEdmBuilder getBuilder() { if (builder == null) { builder = new JPAEdmEntityContainerBuilder(); } return builder; } JPAEdmEntityContainer(final JPAEdmSchemaView view); @Override JPAEdmBuilder getBuilder(); @Override EntityContainer getEdmEntityContainer(); @Override List<EntityContainer> getConsistentEdmEntityContainerList(); @Override JPAEdmEntitySetView getJPAEdmEntitySetView(); @Override JPAEdmAssociationSetView getEdmAssociationSetView(); @Override void clean(); } | @Test public void testGetBuilder() { assertNotNull(objJPAEdmEntityContainer.getBuilder()); }
@Test public void testGetBuilderIdempotent() { JPAEdmBuilder builder1 = objJPAEdmEntityContainer.getBuilder(); JPAEdmBuilder builder2 = objJPAEdmEntityContainer.getBuilder(); assertEquals(builder1.hashCode(), builder2.hashCode()); } |
JPAEdmEntityContainer extends JPAEdmBaseViewImpl implements
JPAEdmEntityContainerView { @Override public EntityContainer getEdmEntityContainer() { return currentEntityContainer; } JPAEdmEntityContainer(final JPAEdmSchemaView view); @Override JPAEdmBuilder getBuilder(); @Override EntityContainer getEdmEntityContainer(); @Override List<EntityContainer> getConsistentEdmEntityContainerList(); @Override JPAEdmEntitySetView getJPAEdmEntitySetView(); @Override JPAEdmAssociationSetView getEdmAssociationSetView(); @Override void clean(); } | @Test public void testGetEdmEntityContainer() { assertNotNull(objJPAEdmEntityContainer.getEdmEntityContainer()); assertTrue(objJPAEdmEntityContainer.getEdmEntityContainer().getEntitySets().size() > 0); } |
JPAEdmEntityContainer extends JPAEdmBaseViewImpl implements
JPAEdmEntityContainerView { @Override public List<EntityContainer> getConsistentEdmEntityContainerList() { return consistentEntityContainerList; } JPAEdmEntityContainer(final JPAEdmSchemaView view); @Override JPAEdmBuilder getBuilder(); @Override EntityContainer getEdmEntityContainer(); @Override List<EntityContainer> getConsistentEdmEntityContainerList(); @Override JPAEdmEntitySetView getJPAEdmEntitySetView(); @Override JPAEdmAssociationSetView getEdmAssociationSetView(); @Override void clean(); } | @Test public void testGetConsistentEdmEntityContainerList() { assertNotNull(objJPAEdmEntityContainer.getConsistentEdmEntityContainerList()); assertTrue(objJPAEdmEntityContainer.getConsistentEdmEntityContainerList().size() > 0); } |
JPAEdmEntityContainer extends JPAEdmBaseViewImpl implements
JPAEdmEntityContainerView { @Override public JPAEdmEntitySetView getJPAEdmEntitySetView() { return entitySetView; } JPAEdmEntityContainer(final JPAEdmSchemaView view); @Override JPAEdmBuilder getBuilder(); @Override EntityContainer getEdmEntityContainer(); @Override List<EntityContainer> getConsistentEdmEntityContainerList(); @Override JPAEdmEntitySetView getJPAEdmEntitySetView(); @Override JPAEdmAssociationSetView getEdmAssociationSetView(); @Override void clean(); } | @Test public void testGetJPAEdmEntitySetView() { assertNotNull(objJPAEdmEntityContainer.getJPAEdmEntitySetView()); assertEquals("salesorderprocessing", objJPAEdmEntityContainer.getJPAEdmEntitySetView().getpUnitName()); } |
JPAEdmEntityContainer extends JPAEdmBaseViewImpl implements
JPAEdmEntityContainerView { @Override public void clean() { super.clean(); entitySetView = null; associationSetView = null; currentEntityContainer = null; consistentEntityContainerList = null; } JPAEdmEntityContainer(final JPAEdmSchemaView view); @Override JPAEdmBuilder getBuilder(); @Override EntityContainer getEdmEntityContainer(); @Override List<EntityContainer> getConsistentEdmEntityContainerList(); @Override JPAEdmEntitySetView getJPAEdmEntitySetView(); @Override JPAEdmAssociationSetView getEdmAssociationSetView(); @Override void clean(); } | @Test public void testIsConsistent() { assertTrue(objJPAEdmEntityContainer.isConsistent()); objJPAEdmEntityContainer.clean(); assertFalse(objJPAEdmEntityContainer.isConsistent()); } |
JPAEdmEntityContainer extends JPAEdmBaseViewImpl implements
JPAEdmEntityContainerView { @Override public JPAEdmAssociationSetView getEdmAssociationSetView() { return associationSetView; } JPAEdmEntityContainer(final JPAEdmSchemaView view); @Override JPAEdmBuilder getBuilder(); @Override EntityContainer getEdmEntityContainer(); @Override List<EntityContainer> getConsistentEdmEntityContainerList(); @Override JPAEdmEntitySetView getJPAEdmEntitySetView(); @Override JPAEdmAssociationSetView getEdmAssociationSetView(); @Override void clean(); } | @Test public void testGetEdmAssociationSetView() { assertNotNull(objJPAEdmEntityContainer.getEdmAssociationSetView()); } |
DataContainer { public void init() { Team team1 = createTeam(); team1.setScrumTeam(false); teams.add(team1); Team team2 = createTeam(); team2.setScrumTeam(true); teams.add(team2); Team team3 = createTeam(); team3.setScrumTeam(false); teams.add(team3); Building building1 = createBuilding(); buildings.add(building1); Building building2 = createBuilding(); buildings.add(building2); Building building3 = createBuilding(); buildings.add(building3); Room room1 = createRoom(); room1.setSeats(1); room1.setBuilding(building1); building1.getRooms().add(room1); room1.setVersion(1); rooms.add(room1); Room room2 = createRoom(); room2.setSeats(5); room2.setBuilding(building2); building2.getRooms().add(room2); room2.setVersion(2); rooms.add(room2); Room room3 = createRoom(); room3.setSeats(2); room3.setBuilding(building2); building2.getRooms().add(room3); room3.setVersion(3); rooms.add(room3); for (int i = 4; i <= 103; i++) { Room roomN = createRoom(); roomN.setSeats(4 + (i - 3) % 5); roomN.setBuilding(building3); building3.getRooms().add(roomN); roomN.setVersion(1); rooms.add(roomN); } Manager emp1 = createManager(); emp1.setEmployeeName("Walter Winter"); emp1.setAge(52); emp1.setTeam(team1); team1.getEmployees().add(emp1); emp1.setRoom(room1); room1.getEmployees().add(emp1); emp1.setManager(emp1); emp1.getEmployees().add(emp1); emp1.setLocation(new Location("Germany", "69124", "Heidelberg")); emp1.setEntryDate(generateDate(1999, 1, 1)); emp1.setImageUri("Employees('1')/$value"); emp1.setImage("/male_1_WinterW.jpg"); emp1.setImageType(IMAGE_JPEG); employees.add(emp1); managers.add(emp1); Employee emp2 = createEmployee(); emp2.setEmployeeName("Frederic Fall"); emp2.setAge(32); emp2.setTeam(team1); team1.getEmployees().add(emp2); emp2.setRoom(room2); room2.getEmployees().add(emp2); emp2.setManager(emp1); emp1.getEmployees().add(emp2); emp2.setLocation(new Location("Germany", "69190", "Walldorf")); emp2.setEntryDate(generateDate(2003, 7, 1)); emp2.setImageUri("Employees('2')/$value"); emp2.setImage("/male_2_FallF.jpg"); emp2.setImageType(IMAGE_JPEG); employees.add(emp2); Manager emp3 = createManager(); emp3.setEmployeeName("Jonathan Smith"); emp3.setAge(56); emp3.setTeam(team1); team1.getEmployees().add(emp3); emp3.setRoom(room2); room2.getEmployees().add(emp3); emp3.setManager(emp1); emp1.getEmployees().add(emp3); emp3.setLocation(emp2.getLocation()); emp3.setEntryDate(null); emp3.setImageUri("Employees('3')/$value"); emp3.setImage("/male_3_SmithJo.jpg"); emp3.setImageType(IMAGE_JPEG); employees.add(emp3); managers.add(emp3); Employee emp4 = createEmployee(); emp4.setEmployeeName("Peter Burke"); emp4.setAge(39); emp4.setTeam(team2); team2.getEmployees().add(emp4); emp4.setRoom(room2); room2.getEmployees().add(emp4); emp4.setManager(emp3); emp3.getEmployees().add(emp4); emp4.setLocation(emp2.getLocation()); emp4.setEntryDate(generateDate(2004, 9, 12)); emp4.setImageUri("Employees('4')/$value"); emp4.setImage("/male_4_BurkeP.jpg"); emp4.setImageType(IMAGE_JPEG); employees.add(emp4); Employee emp5 = createEmployee(); emp5.setEmployeeName("John Field"); emp5.setAge(42); emp5.setTeam(team2); team2.getEmployees().add(emp5); emp5.setRoom(room3); room3.getEmployees().add(emp5); emp5.setManager(emp3); emp3.getEmployees().add(emp5); emp5.setLocation(emp2.getLocation()); emp5.setEntryDate(generateDate(2001, 2, 1)); emp5.setImageUri("Employees('5')/$value"); emp5.setImage("/male_5_FieldJ.jpg"); emp5.setImageType(IMAGE_JPEG); employees.add(emp5); Employee emp6 = createEmployee(); emp6.setEmployeeName("Susan Bay"); emp6.setAge(29); emp6.setTeam(team3); team3.getEmployees().add(emp6); emp6.setRoom(room2); room2.getEmployees().add(emp6); emp6.setManager(emp1); emp1.getEmployees().add(emp6); emp6.setLocation(emp2.getLocation()); emp6.setEntryDate(generateDate(2010, 12, 1)); emp6.setImageUri("Employees('6')/$value"); emp6.setImage("/female_6_BaySu.jpg"); emp6.setImageType(IMAGE_JPEG); employees.add(emp6); Photo photo1 = createPhoto("image/png"); photo1.setContent("Образ"); photos.add(photo1); Photo photo2 = createPhoto("image/bmp"); photos.add(photo2); Photo photo3 = createPhoto(IMAGE_JPEG); photos.add(photo3); Photo photo4 = createPhoto("foo"); photo4.setContent("Продукт"); photos.add(photo4); } void init(); Employee createEmployee(); Team createTeam(); Room createRoom(); Manager createManager(); Building createBuilding(); Photo createPhoto(final String type); List<Employee> getEmployees(); List<Team> getTeams(); List<Room> getRooms(); List<Manager> getManagers(); List<Building> getBuildings(); List<Photo> getPhotos(); void reset(); } | @Test public void testInit() { dataContainer.init(); assertFalse(dataContainer.getEmployees().isEmpty()); assertFalse(dataContainer.getTeams().isEmpty()); assertFalse(dataContainer.getRooms().isEmpty()); assertFalse(dataContainer.getManagers().isEmpty()); assertFalse(dataContainer.getBuildings().isEmpty()); assertFalse(dataContainer.getPhotos().isEmpty()); } |
JPAEdmSchema extends JPAEdmBaseViewImpl implements
JPAEdmSchemaView { @Override public void clean() { super.clean(); schema = null; } JPAEdmSchema(final JPAEdmModelView modelView); @Override List<String> getNonKeyComplexTypeList(); @Override void addNonKeyComplexName(final String complexTypeName); @Override Schema getEdmSchema(); @Override JPAEdmEntityContainerView getJPAEdmEntityContainerView(); @Override JPAEdmComplexTypeView getJPAEdmComplexTypeView(); @Override JPAEdmBuilder getBuilder(); @Override void clean(); @Override final JPAEdmAssociationView getJPAEdmAssociationView(); @Override void registerOperations(final Class<?> customClass, final String[] methodNames); @Override HashMap<Class<?>, String[]> getRegisteredOperations(); } | @Test public void testClean() { assertTrue(objJPAEdmSchema.isConsistent()); objJPAEdmSchema.clean(); assertFalse(objJPAEdmSchema.isConsistent()); }
@Test public void testIsConsistent() { assertTrue(objJPAEdmSchema.isConsistent()); objJPAEdmSchema.clean(); assertFalse(objJPAEdmSchema.isConsistent()); } |
JPAEdmSchema extends JPAEdmBaseViewImpl implements
JPAEdmSchemaView { @Override public Schema getEdmSchema() { return schema; } JPAEdmSchema(final JPAEdmModelView modelView); @Override List<String> getNonKeyComplexTypeList(); @Override void addNonKeyComplexName(final String complexTypeName); @Override Schema getEdmSchema(); @Override JPAEdmEntityContainerView getJPAEdmEntityContainerView(); @Override JPAEdmComplexTypeView getJPAEdmComplexTypeView(); @Override JPAEdmBuilder getBuilder(); @Override void clean(); @Override final JPAEdmAssociationView getJPAEdmAssociationView(); @Override void registerOperations(final Class<?> customClass, final String[] methodNames); @Override HashMap<Class<?>, String[]> getRegisteredOperations(); } | @Test public void testGetEdmSchema() { assertNull(objJPAEdmSchema.getEdmSchema()); } |
JPAEdmSchema extends JPAEdmBaseViewImpl implements
JPAEdmSchemaView { @Override public JPAEdmEntityContainerView getJPAEdmEntityContainerView() { return entityContainerView; } JPAEdmSchema(final JPAEdmModelView modelView); @Override List<String> getNonKeyComplexTypeList(); @Override void addNonKeyComplexName(final String complexTypeName); @Override Schema getEdmSchema(); @Override JPAEdmEntityContainerView getJPAEdmEntityContainerView(); @Override JPAEdmComplexTypeView getJPAEdmComplexTypeView(); @Override JPAEdmBuilder getBuilder(); @Override void clean(); @Override final JPAEdmAssociationView getJPAEdmAssociationView(); @Override void registerOperations(final Class<?> customClass, final String[] methodNames); @Override HashMap<Class<?>, String[]> getRegisteredOperations(); } | @Test public void testGetJPAEdmEntityContainerView() { assertNull(objJPAEdmSchema.getJPAEdmEntityContainerView()); } |
JPAEdmSchema extends JPAEdmBaseViewImpl implements
JPAEdmSchemaView { @Override public JPAEdmComplexTypeView getJPAEdmComplexTypeView() { return complexTypeView; } JPAEdmSchema(final JPAEdmModelView modelView); @Override List<String> getNonKeyComplexTypeList(); @Override void addNonKeyComplexName(final String complexTypeName); @Override Schema getEdmSchema(); @Override JPAEdmEntityContainerView getJPAEdmEntityContainerView(); @Override JPAEdmComplexTypeView getJPAEdmComplexTypeView(); @Override JPAEdmBuilder getBuilder(); @Override void clean(); @Override final JPAEdmAssociationView getJPAEdmAssociationView(); @Override void registerOperations(final Class<?> customClass, final String[] methodNames); @Override HashMap<Class<?>, String[]> getRegisteredOperations(); } | @Test public void testGetJPAEdmComplexTypeView() { assertNull(objJPAEdmSchema.getJPAEdmComplexTypeView()); } |
JPAEdmSchema extends JPAEdmBaseViewImpl implements
JPAEdmSchemaView { @Override public JPAEdmBuilder getBuilder() { if (builder == null) { builder = new JPAEdmSchemaBuilder(); } return builder; } JPAEdmSchema(final JPAEdmModelView modelView); @Override List<String> getNonKeyComplexTypeList(); @Override void addNonKeyComplexName(final String complexTypeName); @Override Schema getEdmSchema(); @Override JPAEdmEntityContainerView getJPAEdmEntityContainerView(); @Override JPAEdmComplexTypeView getJPAEdmComplexTypeView(); @Override JPAEdmBuilder getBuilder(); @Override void clean(); @Override final JPAEdmAssociationView getJPAEdmAssociationView(); @Override void registerOperations(final Class<?> customClass, final String[] methodNames); @Override HashMap<Class<?>, String[]> getRegisteredOperations(); } | @Test public void testGetBuilder() { assertNotNull(objJPAEdmSchema.getBuilder()); }
@Test public void testGetBuilderIdempotent() { JPAEdmBuilder builder1 = objJPAEdmSchema.getBuilder(); JPAEdmBuilder builder2 = objJPAEdmSchema.getBuilder(); assertEquals(builder1.hashCode(), builder2.hashCode()); } |
JPAEdmSchema extends JPAEdmBaseViewImpl implements
JPAEdmSchemaView { @Override public final JPAEdmAssociationView getJPAEdmAssociationView() { return associationView; } JPAEdmSchema(final JPAEdmModelView modelView); @Override List<String> getNonKeyComplexTypeList(); @Override void addNonKeyComplexName(final String complexTypeName); @Override Schema getEdmSchema(); @Override JPAEdmEntityContainerView getJPAEdmEntityContainerView(); @Override JPAEdmComplexTypeView getJPAEdmComplexTypeView(); @Override JPAEdmBuilder getBuilder(); @Override void clean(); @Override final JPAEdmAssociationView getJPAEdmAssociationView(); @Override void registerOperations(final Class<?> customClass, final String[] methodNames); @Override HashMap<Class<?>, String[]> getRegisteredOperations(); } | @Test public void testGetJPAEdmAssociationView() { assertNull(objJPAEdmSchema.getJPAEdmAssociationView()); } |
JPAEdmEntitySet extends JPAEdmBaseViewImpl implements
JPAEdmEntitySetView { @Override public JPAEdmBuilder getBuilder() { if (builder == null) { builder = new JPAEdmEntitySetBuilder(); } return builder; } JPAEdmEntitySet(final JPAEdmSchemaView view); @Override JPAEdmBuilder getBuilder(); @Override EntitySet getEdmEntitySet(); @Override List<EntitySet> getConsistentEdmEntitySetList(); @Override JPAEdmEntityTypeView getJPAEdmEntityTypeView(); @Override void clean(); } | @Test public void testGetBuilder() { assertNotNull(objJPAEdmEntitySet.getBuilder()); }
@Test public void testGetBuilderIdempotent() { JPAEdmBuilder builder1 = objJPAEdmEntitySet.getBuilder(); JPAEdmBuilder builder2 = objJPAEdmEntitySet.getBuilder(); assertEquals(builder1.hashCode(), builder2.hashCode()); } |
Building { public String getId() { return Integer.toString(id); } Building(final int id, final String name); String getId(); void setName(final String name); String getName(); void setImage(final byte[] byteArray); byte[] getImage(); List<Room> getRooms(); @Override int hashCode(); @Override boolean equals(final Object obj); @Override String toString(); } | @Test public void testId() { Building build1 = new Building(1, null); assertNotNull(build1.getId()); } |
JPAEdmEntitySet extends JPAEdmBaseViewImpl implements
JPAEdmEntitySetView { @Override public EntitySet getEdmEntitySet() { return currentEntitySet; } JPAEdmEntitySet(final JPAEdmSchemaView view); @Override JPAEdmBuilder getBuilder(); @Override EntitySet getEdmEntitySet(); @Override List<EntitySet> getConsistentEdmEntitySetList(); @Override JPAEdmEntityTypeView getJPAEdmEntityTypeView(); @Override void clean(); } | @Test public void testGetEdmEntitySet() { assertNotNull(objJPAEdmEntitySet.getEdmEntitySet()); assertNotNull(objJPAEdmEntitySet.getEdmEntitySet().getEntityType()); } |
JPAEdmEntitySet extends JPAEdmBaseViewImpl implements
JPAEdmEntitySetView { @Override public List<EntitySet> getConsistentEdmEntitySetList() { return consistentEntitySetList; } JPAEdmEntitySet(final JPAEdmSchemaView view); @Override JPAEdmBuilder getBuilder(); @Override EntitySet getEdmEntitySet(); @Override List<EntitySet> getConsistentEdmEntitySetList(); @Override JPAEdmEntityTypeView getJPAEdmEntityTypeView(); @Override void clean(); } | @Test public void testGetConsistentEntitySetList() { assertTrue(objJPAEdmEntitySet.getConsistentEdmEntitySetList().size() > 0); } |
JPAEdmEntitySet extends JPAEdmBaseViewImpl implements
JPAEdmEntitySetView { @Override public JPAEdmEntityTypeView getJPAEdmEntityTypeView() { return entityTypeView; } JPAEdmEntitySet(final JPAEdmSchemaView view); @Override JPAEdmBuilder getBuilder(); @Override EntitySet getEdmEntitySet(); @Override List<EntitySet> getConsistentEdmEntitySetList(); @Override JPAEdmEntityTypeView getJPAEdmEntityTypeView(); @Override void clean(); } | @Test public void testGetJPAEdmEntityTypeView() { assertNotNull(objJPAEdmEntitySet.getJPAEdmEntityTypeView()); assertEquals("salesorderprocessing", objJPAEdmEntitySet.getJPAEdmEntityTypeView().getpUnitName()); } |
JPAEdmNavigationProperty extends JPAEdmBaseViewImpl implements
JPAEdmNavigationPropertyView { @Override public JPAEdmBuilder getBuilder() { if (builder == null) { builder = new JPAEdmNavigationPropertyBuilder(); } return builder; } JPAEdmNavigationProperty(final JPAEdmAssociationView associationView,
final JPAEdmPropertyView propertyView, final int countNumber); JPAEdmNavigationProperty(final JPAEdmSchemaView schemaView); @Override JPAEdmBuilder getBuilder(); @Override NavigationProperty getEdmNavigationProperty(); @Override List<NavigationProperty> getConsistentEdmNavigationProperties(); @Override void addJPAEdmNavigationPropertyView(
final JPAEdmNavigationPropertyView view); } | @Test public void testGetBuilder() { assertNotNull(objNavigationProperty.getBuilder()); }
@Test public void testGetBuilderIdempotent() { JPAEdmBuilder builder1 = objNavigationProperty.getBuilder(); JPAEdmBuilder builder2 = objNavigationProperty.getBuilder(); assertEquals(builder1.hashCode(), builder2.hashCode()); } |
JPAEdmNavigationProperty extends JPAEdmBaseViewImpl implements
JPAEdmNavigationPropertyView { @Override public NavigationProperty getEdmNavigationProperty() { return currentNavigationProperty; } JPAEdmNavigationProperty(final JPAEdmAssociationView associationView,
final JPAEdmPropertyView propertyView, final int countNumber); JPAEdmNavigationProperty(final JPAEdmSchemaView schemaView); @Override JPAEdmBuilder getBuilder(); @Override NavigationProperty getEdmNavigationProperty(); @Override List<NavigationProperty> getConsistentEdmNavigationProperties(); @Override void addJPAEdmNavigationPropertyView(
final JPAEdmNavigationPropertyView view); } | @Test public void testGetEdmNavigationProperty() { if (objNavigationProperty == null || objNavigationProperty.getEdmNavigationProperty() == null) { JPAEdmNavigationPropertyTest localView = new JPAEdmNavigationPropertyTest(); navPropView = new JPAEdmNavigationPropertyTest(); objNavigationProperty = new JPAEdmNavigationProperty(localView, localView, 1); try { objNavigationProperty.getBuilder().build(); } catch (ODataJPAModelException e) { fail(ODataJPATestConstants.EXCEPTION_MSG_PART_1 + e.getMessage() + ODataJPATestConstants.EXCEPTION_MSG_PART_2); } catch (ODataJPARuntimeException e) { fail(ODataJPATestConstants.EXCEPTION_MSG_PART_1 + e.getMessage() + ODataJPATestConstants.EXCEPTION_MSG_PART_2); } } assertEquals( objNavigationProperty.getEdmNavigationProperty().getName(), "StringDetails"); } |
JPAEdmNavigationProperty extends JPAEdmBaseViewImpl implements
JPAEdmNavigationPropertyView { @Override public List<NavigationProperty> getConsistentEdmNavigationProperties() { return consistentNavigationProperties; } JPAEdmNavigationProperty(final JPAEdmAssociationView associationView,
final JPAEdmPropertyView propertyView, final int countNumber); JPAEdmNavigationProperty(final JPAEdmSchemaView schemaView); @Override JPAEdmBuilder getBuilder(); @Override NavigationProperty getEdmNavigationProperty(); @Override List<NavigationProperty> getConsistentEdmNavigationProperties(); @Override void addJPAEdmNavigationPropertyView(
final JPAEdmNavigationPropertyView view); } | @Test public void testGetConsistentEdmNavigationProperties() { assertTrue(objNavigationProperty.getConsistentEdmNavigationProperties() .size() > 0); } |
JPAEdmNavigationProperty extends JPAEdmBaseViewImpl implements
JPAEdmNavigationPropertyView { @Override public void addJPAEdmNavigationPropertyView( final JPAEdmNavigationPropertyView view) { if (view != null && view.isConsistent()) { currentNavigationProperty = view.getEdmNavigationProperty(); consistentNavigationProperties.add(currentNavigationProperty); } } JPAEdmNavigationProperty(final JPAEdmAssociationView associationView,
final JPAEdmPropertyView propertyView, final int countNumber); JPAEdmNavigationProperty(final JPAEdmSchemaView schemaView); @Override JPAEdmBuilder getBuilder(); @Override NavigationProperty getEdmNavigationProperty(); @Override List<NavigationProperty> getConsistentEdmNavigationProperties(); @Override void addJPAEdmNavigationPropertyView(
final JPAEdmNavigationPropertyView view); } | @Test public void testAddJPAEdmNavigationPropertyView() { JPAEdmNavigationPropertyTest localView = new JPAEdmNavigationPropertyTest(); navPropView = new JPAEdmNavigationPropertyTest(); objNavigationProperty = new JPAEdmNavigationProperty(localView, localView, 1); try { objNavigationProperty.getBuilder().build(); } catch (ODataJPAModelException e) { fail(ODataJPATestConstants.EXCEPTION_MSG_PART_1 + e.getMessage() + ODataJPATestConstants.EXCEPTION_MSG_PART_2); } catch (ODataJPARuntimeException e) { fail(ODataJPATestConstants.EXCEPTION_MSG_PART_1 + e.getMessage() + ODataJPATestConstants.EXCEPTION_MSG_PART_2); } objNavigationProperty.addJPAEdmNavigationPropertyView(navPropView); assertTrue(objNavigationProperty.getConsistentEdmNavigationProperties() .size() > 1); } |
JPAEdmModel extends JPAEdmBaseViewImpl implements JPAEdmModelView { @Override public JPAEdmSchemaView getEdmSchemaView() { return schemaView; } JPAEdmModel(final Metamodel metaModel, final String pUnitName); JPAEdmModel(final ODataJPAContext ctx); @Override JPAEdmSchemaView getEdmSchemaView(); @Override JPAEdmBuilder getBuilder(); } | @Test public void testGetEdmSchemaView() { assertNotNull(objJPAEdmModel.getEdmSchemaView()); } |
Building { public String getName() { return name; } Building(final int id, final String name); String getId(); void setName(final String name); String getName(); void setImage(final byte[] byteArray); byte[] getImage(); List<Room> getRooms(); @Override int hashCode(); @Override boolean equals(final Object obj); @Override String toString(); } | @Test public void testName() { Building build1 = new Building(1, VALUE_NAME); assertEquals(VALUE_NAME, build1.getName()); } |
DateUtil { public static String guessTimezoneOffset(String date) { for (Entry<String, String> entry : TIMEZONE_CODE_MAP.entrySet()) { String code = entry.getKey(); String offset = entry.getValue(); String pattern = " \\(?" + code + "\\)?"; if (date.matches(".+" + pattern)) { return date.replaceAll(pattern, offset); } } return date; } static String guessTimezoneOffset(String date); static Date parseDate(String date, DateTimeFormatter df); } | @Test public void guessTimezoneCodeTest() throws Exception { assertEquals("Thu, 04 APR 2013 20:37:27 +10", DateUtil.guessTimezoneOffset("Thu, 04 APR 2013 20:37:27 AEST")); } |
FaviconDownloader { public String downloadFaviconFromPage(String pageUrl, String directory, String fileName) { String faviconUrl = null; try { final FaviconExtractor extractor = new FaviconExtractor(pageUrl); new ReaderHttpClient() { @Override public Void process(InputStream is) throws Exception { extractor.readPage(is); return null; } }.open(new URL(pageUrl)); faviconUrl = extractor.getFavicon(); } catch (Exception e) { log.error("Error extracting icon from feed HTML page", e); } String localFilename = null; if (faviconUrl != null) { localFilename = downloadFavicon(faviconUrl, directory, fileName); } final List<String> filenameList = ImmutableList.of( "favicon.png", "favicon.gif", "favicon.ico", "favicon.jpg", "favicon.jpeg"); Iterator<String> iterator = filenameList.iterator(); while (localFilename == null && iterator.hasNext()) { String filename = iterator.next(); faviconUrl = getFaviconUrl(pageUrl, filename); localFilename = downloadFavicon(faviconUrl, directory, fileName); } if (log.isInfoEnabled()) { if (localFilename != null) { log.info(MessageFormat.format("Favicon successfully downloaded to {0}", localFilename)); } else { log.info(MessageFormat.format("Cannot find a valid favicon for feed {0} at page {1} or at the domain root", fileName, pageUrl)); } } return localFilename; } String downloadFaviconFromPage(String pageUrl, String directory, String fileName); String getFaviconUrl(String pageUrl, String fileName); String downloadFavicon(final String faviconUrl, final String directory, final String fileName); final public ImmutableMap<String, String> FAVICON_MIME_TYPE_MAP; } | @Test public void faviconDownloaderDoubleFineTest() { FaviconDownloader downloader = new FaviconDownloader(); String tempDir = System.getProperty("java.io.tmpdir"); String filename = downloader.downloadFaviconFromPage("/projects/doublefine/double-fine-adventure/posts", tempDir, "favicon"); if (filename == null) { filename = downloader.downloadFaviconFromPage("https: } assertNotNull(filename); assertTrue(new File(filename).exists()); }
@Test public void faviconDownloaderAbstruseGooseTest() { FaviconDownloader downloader = new FaviconDownloader(); String tempDir = System.getProperty("java.io.tmpdir"); String filename = downloader.downloadFaviconFromPage("http: assertNotNull(filename); assertTrue(new File(filename).exists()); } |
DateUtil { public static Date parseDate(String date, DateTimeFormatter df) { if (StringUtils.isBlank(date)) { return null; } try { return df.parseDateTime(date).toDate(); } catch (IllegalArgumentException e) { } String dateWithOffset = guessTimezoneOffset(date); if (!dateWithOffset.equals(date)) { try { return df.parseDateTime(dateWithOffset).toDate(); } catch (IllegalArgumentException e) { } } if (log.isWarnEnabled()) { log.warn(MessageFormat.format("Error parsing date: {0}", date)); } return null; } static String guessTimezoneOffset(String date); static Date parseDate(String date, DateTimeFormatter df); } | @Test public void parseDateTest() throws Exception { assertNotNull(DateUtil.parseDate("Fri Jan 06 2017 16:13:28 GMT+0900 (JST)", RssReader.DF_RSS)); } |
UrlUtil { public static String getBaseUri(Feed feed, Article article) { if (article.getBaseUri() != null) { return article.getBaseUri(); } if (feed.getBaseUri() != null) { return feed.getBaseUri(); } if (feed.getUrl() != null) { try { return getBaseUri(feed.getUrl()); } catch (MalformedURLException e) { } } return null; } static String getBaseUri(Feed feed, Article article); static String getBaseUri(String urlString); static String completeUrl(String baseUrl, String relativeUrl); } | @Test public void getBaseUriTest() throws Exception { assertEquals("http: assertEquals("http: assertEquals("http: assertEquals("http: assertEquals("http: assertEquals("https: } |
UrlUtil { public static String completeUrl(String baseUrl, String relativeUrl) throws MalformedURLException { baseUrl = Strings.nullToEmpty(baseUrl).trim(); relativeUrl = relativeUrl.trim(); if (relativeUrl.toLowerCase().startsWith("http")) { return new URL(relativeUrl).toString(); } if (relativeUrl.toLowerCase().startsWith("mailto:")) { return new URL(relativeUrl).toString(); } if (relativeUrl.startsWith(" URL base = new URL(baseUrl); URL url = new URL(base.getProtocol() + ":" + relativeUrl); return url.toString(); } URL base = new URL(baseUrl); String basePath = base.getPath() != null ? base.getPath() : ""; if (!(basePath.endsWith("/") || relativeUrl.startsWith("/"))) { relativeUrl = "/" + relativeUrl; } if (basePath.endsWith("/") && relativeUrl.startsWith("/")) { relativeUrl = relativeUrl.substring(1); } URL url = new URL(base.getProtocol(), base.getHost(), base.getPort(), basePath + relativeUrl); return url.toString(); } static String getBaseUri(Feed feed, Article article); static String getBaseUri(String urlString); static String completeUrl(String baseUrl, String relativeUrl); } | @Test public void completeUrlTest() throws Exception { assertEquals("http: assertEquals("http: assertEquals("http: assertEquals("http: } |
NetworkUtil { public static boolean mapTcpPort(int port) { try { GatewayDiscover discover = new GatewayDiscover(); discover.discover(); GatewayDevice device = discover.getValidGateway(); if (device != null) { PortMappingEntry portMapping = new PortMappingEntry(); if (device.getSpecificPortMappingEntry(port, "TCP", portMapping)) { log.info(MessageFormat.format("Port TCP {0} already mapped", port)); return true; } else { InetAddress localAddress = device.getLocalAddress(); return device.addPortMapping(port, port, localAddress.getHostAddress(), "TCP", "Sismics Reader"); } } } catch (Exception e) { log.info("Unable to map TCP port", e); } return false; } static boolean mapTcpPort(int port); } | @Test @Ignore public void testUpnp() throws Exception { assertTrue(NetworkUtil.mapTcpPort(4040)); } |
ResourceUtil { public static List<String> list(Class<?> clazz, String path, FilenameFilter filter) throws URISyntaxException, IOException { URL dirUrl = clazz.getResource(path); if (dirUrl != null && dirUrl.getProtocol().equals("file")) { return Arrays.asList(new File(dirUrl.toURI()).list(filter)); } if (dirUrl == null) { String className = clazz.getName().replace(".", "/") + ".class"; dirUrl = clazz.getClassLoader().getResource(className); } if (dirUrl.getProtocol().equals("jar")) { if (path.startsWith("/")) { path = path.substring(1); } if (!path.endsWith("/")) { path = path + "/"; } String jarPath = dirUrl.getPath().substring(5, dirUrl.getPath().indexOf("!")); JarFile jar = new JarFile(URLDecoder.decode(jarPath, "UTF-8")); Set<String> fileSet = new HashSet<String>(); try { Enumeration<JarEntry> entries = jar.entries(); while (entries.hasMoreElements()) { String entryName = entries.nextElement().getName(); if (!entryName.startsWith(path)) { continue; } String name = entryName.substring(path.length()); if (!"".equals(name)) { int checkSubdir = name.indexOf("/"); if (checkSubdir >= 0) { name = name.substring(0, checkSubdir); } if (filter == null || filter.accept(null, name)) { fileSet.add(name); } } } } finally { jar.close(); } return Lists.newArrayList(fileSet); } throw new UnsupportedOperationException(MessageFormat.format("Cannot list files for URL {0}", dirUrl)); } static List<String> list(Class<?> clazz, String path, FilenameFilter filter); static List<String> list(Class<?> clazz, String path); static Map<Object, Object> loadPropertiesFromUrl(URL url); } | @Test public void listFilesTest() throws Exception { List<String> fileList = ResourceUtil.list(Test.class, "/junit/framework"); assertTrue(fileList.contains("Test.class")); fileList = ResourceUtil.list(Test.class, "/junit/framework/"); assertTrue(fileList.contains("Test.class")); fileList = ResourceUtil.list(Test.class, "junit/framework/"); assertTrue(fileList.contains("Test.class")); fileList = ResourceUtil.list(Test.class, "junit/framework/"); assertTrue(fileList.contains("Test.class")); } |
ResourceUtil { public static Map<Object, Object> loadPropertiesFromUrl(URL url) throws RuntimeException { InputStream is = null; try { is = url.openStream(); Properties properties = new Properties(); properties.load(is); return properties; } catch (IOException e) { throw new RuntimeException("Cannot load properties file for url: " + url, e); } finally { if (is != null) { try { is.close(); } catch (Exception e) { } } } } static List<String> list(Class<?> clazz, String path, FilenameFilter filter); static List<String> list(Class<?> clazz, String path); static Map<Object, Object> loadPropertiesFromUrl(URL url); } | @Test public void loadResourceFileTest() { Map<Object, Object> properties = ResourceUtil.loadPropertiesFromUrl(TestResourceUtil.class.getResource("/config.properties")); assertNotNull(properties); assertTrue(properties.size() > 0); } |
RssReader extends DefaultHandler { public void readRssFeed(InputStream is) throws Exception { SAXParserFactory factory = SAXParserFactory.newInstance(); factory.setNamespaceAware(true); factory.setFeature("http: factory.setFeature("http: SAXParser parser = factory.newSAXParser(); Reader reader = new XmlReader(StreamUtil.detectGzip(is), "UTF-8"); InputSource source = new InputSource(reader); try { parser.parse(source, this); } catch (InternalError e) { throw new Exception(e); } if (feedType == FeedType.ATOM) { AtomUrlGuesserStrategy strategy = new AtomUrlGuesserStrategy(); String siteUrl = strategy.guessSiteUrl(atomLinkList); feed.setUrl(siteUrl); if (feed.getBaseUri() == null) { String feedBaseUri = strategy.guessFeedUrl(atomLinkList); if (feedBaseUri != null) { try { feed.setBaseUri(UrlUtil.getBaseUri(feedBaseUri)); } catch (MalformedURLException e) { } } } } validateFeed(); fixGuid(); } RssReader(); void readRssFeed(InputStream is); @Override void startElement(String uri, String localName, String qName, Attributes attributes); @Override void endElement(String uri, String localName, String qName); @Override void characters(char[] ch, int start, int length); @Override void fatalError(SAXParseException e); Feed getFeed(); List<Article> getArticleList(); static final DateTimeFormatter DF_RSS; static final DateTimeFormatter DF_ATOM; static final DateTimeFormatter DF_DC; } | @Test public void htmlLeMessagerFailTest() throws Exception { InputStream is = getClass().getResourceAsStream("/feed/feed_error_lemessager.html"); RssReader reader = new RssReader(); try { reader.readRssFeed(is); Assert.fail("Root element should be wrong"); } catch (Exception e) { assertTrue(e.getMessage().contains("Root element")); } }
@Test public void htmlTooManyRecoveryTest() throws Exception { InputStream is = getClass().getResourceAsStream("/feed/feed_error_toomanyfatalerror.html"); RssReader reader = new RssReader(); try { reader.readRssFeed(is); Assert.fail("Root element should be wrong"); } catch (Exception e) { assertTrue(e.getMessage().contains("Tried to recover too many times")); } } |
HeapUnit { public static HeapImage captureHeap() throws IOException { String path = "target/heapunit/" + System.currentTimeMillis() + ".hprof"; return new SimpleHeapImage(HeapDumpProcuder.makeHeapDump(path, TimeUnit.SECONDS.toMillis(60))); } static HeapImage captureHeap(); } | @Test public void test() throws IOException { @SuppressWarnings("unused") TestInstance tt = new TestInstance(); HeapImage hi = HeapUnit.captureHeap(); System.out.println("String count: " + hi.instanceCount(String.class)); Assert.assertTrue(hi.instanceCount(String.class) > 0); System.out.println("List count: " + hi.instanceCount(List.class)); Assert.assertTrue(hi.instanceCount(List.class) > 0); System.out.println("TestInstance count: " + hi.instanceCount(TestInstance.class)); assertEquals(1, hi.instanceCount(TestInstance.class)); System.out.println("(**$TestInstance) count: " + hi.instanceCount("(**$TestInstance)")); assertEquals(1, hi.instanceCount("(**$TestInstance)")); System.out.println("char[] count: " + hi.instanceCount(char[].class)); Assert.assertTrue(hi.instanceCount(char[].class) > 0); System.out.println("Object[] count: " + hi.instanceCount(Object[].class)); Assert.assertTrue(hi.instanceCount(Object[].class) > 0); TestInstance t2 = hi.rehydrateFirst("(**$TestInstance)"); System.out.println(t2); HeapInstance ti = hi.instance("(**$TestInstance)"); assertEquals(true, ti.value("bval")); assertEquals(10, ti.value("ival")); assertEquals(1.1d, ti.value("dval")); } |
ByteArrayUtils { public static boolean isEqualUsingConstantTime(byte[] val1, byte[] val2) { if (val1.length != val2.length) { return false; } int result = 0; for (int i = 0; i < val1.length; i++) { result |= val1[i] ^ val2[i]; } return result == 0; } static boolean isEqualUsingConstantTime(byte[] val1, byte[] val2); static byte[] generate32RandomBytes(); } | @Test public void isEqualUsingConstantTime() { byte [] bytes = "some bytes".getBytes(); byte [] sameBytes = "some bytes".getBytes(); byte [] differentBytes = "different bytes".getBytes(); assertThat(ByteArrayUtils.isEqualUsingConstantTime(bytes, sameBytes)).isTrue(); assertThat(ByteArrayUtils.isEqualUsingConstantTime(sameBytes, bytes)).isTrue(); assertThat(ByteArrayUtils.isEqualUsingConstantTime(new byte[0], new byte[0])).isTrue(); assertThat(ByteArrayUtils.isEqualUsingConstantTime(bytes, differentBytes)).isFalse(); assertThat(ByteArrayUtils.isEqualUsingConstantTime(differentBytes, bytes)).isFalse(); }
@Test public void isEqualRunsInConstantTime() { int arraySize = 250000; byte [] lotsOfBytes = new byte[arraySize]; Arrays.fill(lotsOfBytes, (byte) 0); byte [] sameLotsOfBytes = new byte[arraySize]; Arrays.fill(sameLotsOfBytes, (byte) 0); byte [] lotsMoreDifferentBytes = new byte[arraySize]; Arrays.fill(lotsMoreDifferentBytes, (byte) 1); int iterations = 10000; for (int i = 0; i < 1000; i++) { assertThat(ByteArrayUtils.isEqualUsingConstantTime(lotsOfBytes, lotsMoreDifferentBytes)).isFalse(); } Stopwatch baseline = Stopwatch.createStarted(); for (int i = 0; i < iterations; i++) { assertThat(ByteArrayUtils.isEqualUsingConstantTime(lotsOfBytes, sameLotsOfBytes)).isTrue(); } baseline.stop(); Stopwatch test = Stopwatch.createStarted(); for (int i = 0; i < iterations; i++) { assertThat(ByteArrayUtils.isEqualUsingConstantTime(lotsOfBytes, lotsMoreDifferentBytes)).isFalse(); } test.stop(); assertThat(test.elapsed().toMillis()).isCloseTo(baseline.elapsed().toMillis(), Percentage.withPercentage(75.0)); } |
InMemoryRoutingTable implements RoutingTable<R> { @Override public Optional<R> removeRoute(final InterledgerAddressPrefix addressPrefix) { Objects.requireNonNull(addressPrefix); return this.interledgerAddressPrefixMap.removeEntry(addressPrefix); } InMemoryRoutingTable(); InMemoryRoutingTable(final InterledgerAddressPrefixMap interledgerAddressPrefixMap); @Override R addRoute(final R route); @Override Optional<R> removeRoute(final InterledgerAddressPrefix addressPrefix); @Override Optional<R> getRouteByPrefix(final InterledgerAddressPrefix addressPrefix); @Override Iterable<InterledgerAddressPrefix> getAllPrefixes(); @Override void forEach(final BiConsumer<InterledgerAddressPrefix, R> action); @Override Optional<R> findNextHopRoute(final InterledgerAddress interledgerAddress); @Override void reset(); } | @Test(expected = NullPointerException.class) public void testRemoveRouteNull() { try { this.routingTable.removeRoute(null); } catch (NullPointerException e) { throw e; } }
@Test public void testRemoveRoute() { final Route route = this.constructTestRoute(GLOBAL_PREFIX); this.routingTable.removeRoute(route.routePrefix()); verify(interledgerPrefixMapMock).removeEntry(route.routePrefix()); verifyNoMoreInteractions(interledgerPrefixMapMock); } |
InMemoryRoutingTable implements RoutingTable<R> { @Override public Optional<R> getRouteByPrefix(final InterledgerAddressPrefix addressPrefix) { Objects.requireNonNull(addressPrefix); return this.interledgerAddressPrefixMap.getEntry(addressPrefix); } InMemoryRoutingTable(); InMemoryRoutingTable(final InterledgerAddressPrefixMap interledgerAddressPrefixMap); @Override R addRoute(final R route); @Override Optional<R> removeRoute(final InterledgerAddressPrefix addressPrefix); @Override Optional<R> getRouteByPrefix(final InterledgerAddressPrefix addressPrefix); @Override Iterable<InterledgerAddressPrefix> getAllPrefixes(); @Override void forEach(final BiConsumer<InterledgerAddressPrefix, R> action); @Override Optional<R> findNextHopRoute(final InterledgerAddress interledgerAddress); @Override void reset(); } | @Test(expected = NullPointerException.class) public void testGetRoutesNull() { try { this.routingTable.getRouteByPrefix(null); } catch (NullPointerException e) { throw e; } }
@Test public void testGetRoutes() { final Route route = this.constructTestRoute(GLOBAL_PREFIX); this.routingTable.getRouteByPrefix(route.routePrefix()); verify(interledgerPrefixMapMock).getEntry(route.routePrefix()); verifyNoMoreInteractions(interledgerPrefixMapMock); } |
InMemoryRoutingTable implements RoutingTable<R> { @Override public void forEach(final BiConsumer<InterledgerAddressPrefix, R> action) { Objects.requireNonNull(action); this.interledgerAddressPrefixMap.forEach(action); } InMemoryRoutingTable(); InMemoryRoutingTable(final InterledgerAddressPrefixMap interledgerAddressPrefixMap); @Override R addRoute(final R route); @Override Optional<R> removeRoute(final InterledgerAddressPrefix addressPrefix); @Override Optional<R> getRouteByPrefix(final InterledgerAddressPrefix addressPrefix); @Override Iterable<InterledgerAddressPrefix> getAllPrefixes(); @Override void forEach(final BiConsumer<InterledgerAddressPrefix, R> action); @Override Optional<R> findNextHopRoute(final InterledgerAddress interledgerAddress); @Override void reset(); } | @Test(expected = NullPointerException.class) public void testForEachNull() { try { this.routingTable.forEach(null); } catch (NullPointerException e) { throw e; } }
@Test public void testForEach() { final BiConsumer<String, Collection<Route>> action = (o, o2) -> { }; this.routingTable.forEach(action); verify(interledgerPrefixMapMock).forEach(action); verifyNoMoreInteractions(interledgerPrefixMapMock); } |
InMemoryRoutingTable implements RoutingTable<R> { @Override public Optional<R> findNextHopRoute(final InterledgerAddress interledgerAddress) { Objects.requireNonNull(interledgerAddress, "finalDestinationAddress must not be null!"); return this.interledgerAddressPrefixMap.findNextHop(interledgerAddress); } InMemoryRoutingTable(); InMemoryRoutingTable(final InterledgerAddressPrefixMap interledgerAddressPrefixMap); @Override R addRoute(final R route); @Override Optional<R> removeRoute(final InterledgerAddressPrefix addressPrefix); @Override Optional<R> getRouteByPrefix(final InterledgerAddressPrefix addressPrefix); @Override Iterable<InterledgerAddressPrefix> getAllPrefixes(); @Override void forEach(final BiConsumer<InterledgerAddressPrefix, R> action); @Override Optional<R> findNextHopRoute(final InterledgerAddress interledgerAddress); @Override void reset(); } | @Test(expected = NullPointerException.class) public void testFindNextHopRouteNull() { try { this.routingTable.findNextHopRoute(null); } catch (NullPointerException e) { throw e; } }
@Test public void testFindNextHopRoute() { this.routingTable.findNextHopRoute(BOB_GLOBAL_ADDRESS); verify(interledgerPrefixMapMock).findNextHop(BOB_GLOBAL_ADDRESS); verifyNoMoreInteractions(interledgerPrefixMapMock); } |
InMemoryExternalRoutingService implements ExternalRoutingService { @Override public void start() { this.initRoutingTables(); } InMemoryExternalRoutingService(
final EventBus eventBus,
final Supplier<ConnectorSettings> connectorSettingsSupplier,
final Decryptor decryptor,
final AccountSettingsRepository accountSettingsRepository,
final StaticRoutesRepository staticRoutesRepository,
final LocalDestinationAddressPaymentRouter localDestinationAddressPaymentRouter,
final RoutingTable<Route> localRoutingTable,
final ForwardingRoutingTable<RouteUpdate> outgoingRoutingTable,
final RouteBroadcaster routeBroadcaster
); @Override void start(); @Override List<Route> getAllRoutes(); @Override Optional<Route> findBestNexHop(final InterledgerAddress finalDestinationAddress); @Override Set<StaticRoute> getAllStaticRoutes(); @Override void deleteStaticRouteByPrefix(InterledgerAddressPrefix prefix); @Override StaticRoute createStaticRoute(StaticRoute route); } | @Test public void peersAndParentsGetsAutoRegisteredForCcp() { LinkType ilpoverhttp = LinkType.of("ILPOVERHTTP"); AccountSettings peer = AccountSettings.builder() .assetCode("XRP") .assetScale(9) .linkType(ilpoverhttp) .accountId(AccountId.of("peer")) .accountRelationship(AccountRelationship.PEER) .build(); AccountSettings child = AccountSettings.builder() .assetCode("XRP") .assetScale(9) .linkType(ilpoverhttp) .accountId(AccountId.of("child")) .accountRelationship(AccountRelationship.CHILD) .build(); AccountSettings parent = AccountSettings.builder() .assetCode("XRP") .assetScale(9) .linkType(ilpoverhttp) .accountId(AccountId.of("parent")) .accountRelationship(AccountRelationship.PARENT) .build(); when(accountSettingsRepository.findByAccountRelationshipIsWithConversion(AccountRelationship.PEER)) .thenReturn(Lists.newArrayList(peer)); when(accountSettingsRepository.findByAccountRelationshipIsWithConversion(AccountRelationship.PARENT)) .thenReturn(Lists.newArrayList(parent)); service.start(); verify(routeBroadcaster, times(1)).registerCcpEnabledAccount(peer); verify(routeBroadcaster, times(1)).registerCcpEnabledAccount(parent); verify(routeBroadcaster, times(0)).registerCcpEnabledAccount(child); }
@Test public void misconfiguredAccountsAreGracefullyHandled() { LinkType ilpoverhttp = LinkType.of("ILPOVERHTTP"); AccountSettings goodPeer = AccountSettings.builder() .assetCode("XRP") .assetScale(9) .linkType(ilpoverhttp) .accountId(AccountId.of("good_peer")) .accountRelationship(AccountRelationship.PEER) .build(); AccountSettings badPeer = AccountSettings.builder() .assetCode("XRP") .assetScale(9) .linkType(ilpoverhttp) .accountId(AccountId.of("bad_peer")) .accountRelationship(AccountRelationship.PEER) .build(); when(accountSettingsRepository.findByAccountRelationshipIsWithConversion(AccountRelationship.PEER)) .thenReturn(Lists.newArrayList(badPeer, goodPeer)); when(routeBroadcaster.registerCcpEnabledAccount(badPeer)).thenThrow(new RuntimeException("fake exception!")); when(routeBroadcaster.registerCcpEnabledAccount(goodPeer)).thenReturn(Optional.empty()); service.start(); verify(routeBroadcaster, times(1)).registerCcpEnabledAccount(badPeer); verify(routeBroadcaster, times(1)).registerCcpEnabledAccount(goodPeer); } |
ConnectorServer extends Server { @Override public void start() { super.start(); if (SpringProfileUtils.isProfileActive(getContext().getEnvironment(), "MIGRATE-ONLY")) { System.out.println("###################################################################"); System.out.println("!!! Container started with migrate-only profile. Shutting down. !!!"); System.out.println("###################################################################"); this.stop(); return; } this.emitFxInfo(); if (getConnectorSettings().get().operatorAddress().equals(Link.SELF)) { logger.info("STARTED INTERLEDGER CHILD CONNECTOR: [Operator Address pending IL-DCP]"); } else { logger.info("STARTED INTERLEDGER CONNECTOR: `{}`", getConnectorSettings().get().operatorAddress()); } } ConnectorServer(); ConnectorServer(final ConnectorSettings connectorSettings); @Override void start(); @Override void onApplicationEvent(final ApplicationEvent event); } | @Test public void migrateOnlyCallsStop() throws InterruptedException { System.setProperty(SPRING_PROFILES_ACTIVE, "migrate-only,test"); System.setProperty(SERVER_PORT, "0"); connectorServer.start(); assertThat(connectorServer.getContext().isActive()).isFalse(); }
@Test public void serverActiveAfterStart() { System.setProperty(SPRING_PROFILES_ACTIVE, "test"); System.setProperty(SERVER_PORT, "0"); connectorServer.start(); assertThat(connectorServer.getContext().isActive()).isTrue(); } |
InMemoryExternalRoutingService implements ExternalRoutingService { @Override public Optional<Route> findBestNexHop(final InterledgerAddress finalDestinationAddress) { Objects.requireNonNull(finalDestinationAddress); return localDestinationAddressPaymentRouter.findBestNexHop(finalDestinationAddress) .map(Optional::ofNullable) .orElseGet(() -> localRoutingTable.findNextHopRoute(finalDestinationAddress)); } InMemoryExternalRoutingService(
final EventBus eventBus,
final Supplier<ConnectorSettings> connectorSettingsSupplier,
final Decryptor decryptor,
final AccountSettingsRepository accountSettingsRepository,
final StaticRoutesRepository staticRoutesRepository,
final LocalDestinationAddressPaymentRouter localDestinationAddressPaymentRouter,
final RoutingTable<Route> localRoutingTable,
final ForwardingRoutingTable<RouteUpdate> outgoingRoutingTable,
final RouteBroadcaster routeBroadcaster
); @Override void start(); @Override List<Route> getAllRoutes(); @Override Optional<Route> findBestNexHop(final InterledgerAddress finalDestinationAddress); @Override Set<StaticRoute> getAllStaticRoutes(); @Override void deleteStaticRouteByPrefix(InterledgerAddressPrefix prefix); @Override StaticRoute createStaticRoute(StaticRoute route); } | @Test public void testFindBestNexHopFromLocalPaymentRouter() { final Route routeMock = mock(Route.class); when(localDestinationAddressPaymentRouter.findBestNexHop(any())).thenReturn(Optional.of(routeMock)); final Optional<Route> actual = service.findBestNexHop(InterledgerAddress.of("example.foo.bar")); assertThat(actual).isPresent(); assertThat(actual.get()).isEqualTo(routeMock); }
@Test public void testFindBestNexHopFromForwardingPaymentRouter() { final Route routeMock = mock(Route.class); when(localDestinationAddressPaymentRouter.findBestNexHop(any())).thenReturn(Optional.empty()); when(localRoutingTableMock.findNextHopRoute(any())).thenReturn(Optional.of(routeMock)); final Optional<Route> actual = service.findBestNexHop(InterledgerAddress.of("example.foo.bar")); assertThat(actual).isPresent(); assertThat(actual.get()).isEqualTo(routeMock); }
@Test public void testFindBestNexHopWhenBothTablesAreEmpty() { when(localDestinationAddressPaymentRouter.findBestNexHop(any())).thenReturn(Optional.empty()); when(localRoutingTableMock.findNextHopRoute(any())).thenReturn(Optional.empty()); final Optional<Route> actual = service.findBestNexHop(InterledgerAddress.of("example.foo.bar")); assertThat(actual).isNotPresent(); } |
InMemoryStreamPaymentManager implements StreamPaymentManager { @Override public synchronized void merge(StreamPayment streamPayment) { StreamPayment merged = upsertAmounts(streamPayment); if (streamPayment.deliveredAssetCode().isPresent()) { merged = put(StreamPayment.builder().from(merged) .deliveredAssetCode(streamPayment.deliveredAssetCode()) .deliveredAssetScale(streamPayment.deliveredAssetScale()) .build()); } if (!streamPayment.status().equals(StreamPaymentStatus.PENDING)) { put(StreamPayment.builder().from(merged) .status(streamPayment.status()) .build()); } } @Override List<StreamPayment> findByAccountId(AccountId accountId, PageRequest pageRequest); @Override Optional<StreamPayment> findByAccountIdAndStreamPaymentId(AccountId accountId, String streamPaymentId); @Override synchronized void merge(StreamPayment streamPayment); } | @Test public void merge() { AccountId accountId = AccountId.of(generateUuid()); String streamPaymentId = generateUuid(); String streamPaymentId2 = generateUuid(); final StreamPayment entity1 = newTransaction(accountId, streamPaymentId, 10); paymentTransactionManager.merge(entity1); final StreamPayment loadedAccessTokenEntity = paymentTransactionManager.findByAccountIdAndStreamPaymentId(accountId, streamPaymentId).get(); assertEqual(loadedAccessTokenEntity, entity1); final StreamPayment entity2 = newTransaction(accountId, streamPaymentId, 20); paymentTransactionManager.merge(entity2); assertThat(paymentTransactionManager.findByAccountId(accountId, DEFAULT_PAGE)).hasSize(1); Optional<StreamPayment> transaction1 = paymentTransactionManager.findByAccountIdAndStreamPaymentId(accountId, streamPaymentId); assertThat(transaction1).isPresent(); assertThat(transaction1.get().packetCount()).isEqualTo(2); assertThat(transaction1.get().amount()).isEqualTo(BigInteger.valueOf(30)); paymentTransactionManager.merge(newTransaction(accountId, streamPaymentId2, 33)); assertThat(paymentTransactionManager.findByAccountId(accountId, DEFAULT_PAGE)).hasSize(2); Optional<StreamPayment> transaction1Again = paymentTransactionManager.findByAccountIdAndStreamPaymentId(accountId, streamPaymentId); Optional<StreamPayment> transaction2 = paymentTransactionManager.findByAccountIdAndStreamPaymentId(accountId, streamPaymentId2); assertEqual(transaction1Again.get(), transaction1.get()); assertThat(transaction2).isPresent(); assertThat(transaction2.get().amount()).isEqualTo(BigInteger.valueOf(33)); assertThat(transaction2.get().packetCount()).isEqualTo(1); } |
FulfillmentGeneratedEventConverter implements Converter<FulfillmentGeneratedEvent, StreamPayment> { @Override public StreamPayment convert(FulfillmentGeneratedEvent source) { Optional<StreamPacket> prepareStreamPacket = streamPreparePacket(source.preparePacket(), source.fulfillPacket()); Optional<StreamPacket> fulfillStreamPacket = streamFulfillPacket(source.preparePacket(), source.fulfillPacket()); Optional<InterledgerAddress> sourceAddress = prepareStreamPacket.flatMap(StreamPacketUtils::getSourceAddress); ImmutableStreamPayment.Builder builder = StreamPayment.builder() .destinationAddress(source.preparePacket().getDestination()) .sourceAddress(sourceAddress) .status(getTransactionStatus(prepareStreamPacket).orElseGet( () -> getTransactionStatus(fulfillStreamPacket).orElse(StreamPaymentStatus.PENDING) )) .packetCount(1) .modifiedAt(Instant.now()) .createdAt(Instant.now()) .assetScale(source.denomination().assetScale()) .assetCode(source.denomination().assetCode()) .accountId(source.accountId()); switch (source.paymentType()) { case PAYMENT_RECEIVED: { return builder.amount(source.preparePacket().getAmount().bigIntegerValue()) .deliveredAmount(source.preparePacket().getAmount()) .deliveredAssetScale(source.denomination().assetScale()) .deliveredAssetCode(source.denomination().assetCode()) .type(StreamPaymentType.PAYMENT_RECEIVED) .build(); } case PAYMENT_SENT: { Optional<Denomination> deliveredDenomination = fulfillStreamPacket.flatMap(StreamPacketUtils::getDenomination); return builder.amount(source.preparePacket().getAmount().bigIntegerValue().negate()) .deliveredAmount(fulfillStreamPacket.map(StreamPacket::prepareAmount).orElse(UnsignedLong.ZERO)) .deliveredAssetScale(deliveredDenomination.map(Denomination::assetScale)) .deliveredAssetCode(deliveredDenomination.map(Denomination::assetCode)) .type(StreamPaymentType.PAYMENT_SENT) .build(); } default: throw new IllegalArgumentException("found unmapped paymentType " + source.paymentType() + " for event: " + source); } } FulfillmentGeneratedEventConverter(StreamEncryptionService streamEncryptionService,
CodecContext streamCodecContext); @Override StreamPayment convert(FulfillmentGeneratedEvent source); } | @Test public void convertPaymentReceived() { long amount = 100; StreamPacket streamPacket = StreamPacket.builder() .interledgerPacketType(InterledgerPacketType.PREPARE) .sequence(UnsignedLong.ONE) .prepareAmount(UnsignedLong.valueOf(10)) .addFrames(moneyFrame()) .build(); FulfillmentGeneratedEvent event = FulfillmentGeneratedEvent.builder() .preparePacket(preparePacket(amount, streamPacket)) .accountId(ACCOUNT_ID) .denomination(DENOMINATION) .paymentType(StreamPaymentType.PAYMENT_RECEIVED) .fulfillPacket(InterledgerFulfillPacket.builder() .fulfillment(InterledgerFulfillment.of(new byte[32])) .data(new byte[0]) .build() ) .build(); StreamPayment streamPayment = converter.convert(event); StreamPayment expected = StreamPayment.builder() .assetScale(DENOMINATION.assetScale()) .assetCode(DENOMINATION.assetCode()) .status(StreamPaymentStatus.PENDING) .accountId(ACCOUNT_ID) .amount(BigInteger.valueOf(amount)) .packetCount(1) .deliveredAmount(UnsignedLong.valueOf(amount)) .deliveredAssetScale(DENOMINATION.assetScale()) .deliveredAssetCode(DENOMINATION.assetCode()) .destinationAddress(DESTINATION_ADDRESS) .createdAt(streamPayment.createdAt()) .modifiedAt(streamPayment.modifiedAt()) .type(StreamPaymentType.PAYMENT_RECEIVED) .build(); assertThat(streamPayment).isEqualTo(expected); }
@Test public void convertPaymentReceivedWithoutTypedData() { long amount = 100; FulfillmentGeneratedEvent event = FulfillmentGeneratedEvent.builder() .preparePacket(preparePacket(amount, Optional.empty())) .accountId(ACCOUNT_ID) .denomination(DENOMINATION) .paymentType(StreamPaymentType.PAYMENT_RECEIVED) .fulfillPacket(InterledgerFulfillPacket.builder() .fulfillment(InterledgerFulfillment.of(new byte[32])) .data(new byte[0]) .build() ) .build(); StreamPayment streamPayment = converter.convert(event); StreamPayment expected = StreamPayment.builder() .assetScale(DENOMINATION.assetScale()) .assetCode(DENOMINATION.assetCode()) .status(StreamPaymentStatus.PENDING) .accountId(ACCOUNT_ID) .amount(BigInteger.valueOf(amount)) .packetCount(1) .deliveredAmount(UnsignedLong.valueOf(amount)) .deliveredAssetScale(DENOMINATION.assetScale()) .deliveredAssetCode(DENOMINATION.assetCode()) .destinationAddress(DESTINATION_ADDRESS) .createdAt(streamPayment.createdAt()) .modifiedAt(streamPayment.modifiedAt()) .type(StreamPaymentType.PAYMENT_RECEIVED) .build(); assertThat(streamPayment).isEqualTo(expected); }
@Test public void convertWithClosingFrameOnPrepare() { long amount = 100; StreamPacket streamPacket = StreamPacket.builder() .interledgerPacketType(InterledgerPacketType.PREPARE) .sequence(UnsignedLong.ONE) .prepareAmount(UnsignedLong.valueOf(10)) .addFrames(moneyFrame()) .addFrames(closeFrame()) .build(); FulfillmentGeneratedEvent event = FulfillmentGeneratedEvent.builder() .preparePacket(preparePacket(amount, streamPacket)) .accountId(ACCOUNT_ID) .denomination(DENOMINATION) .paymentType(StreamPaymentType.PAYMENT_RECEIVED) .fulfillPacket(InterledgerFulfillPacket.builder() .fulfillment(InterledgerFulfillment.of(new byte[32])) .data(new byte[0]) .build() ) .build(); StreamPayment streamPayment = converter.convert(event); StreamPayment expected = StreamPayment.builder() .assetScale(DENOMINATION.assetScale()) .assetCode(DENOMINATION.assetCode()) .status(StreamPaymentStatus.CLOSED_BY_STREAM) .accountId(ACCOUNT_ID) .amount(BigInteger.valueOf(amount)) .packetCount(1) .deliveredAmount(UnsignedLong.valueOf(amount)) .deliveredAssetScale(DENOMINATION.assetScale()) .deliveredAssetCode(DENOMINATION.assetCode()) .destinationAddress(DESTINATION_ADDRESS) .createdAt(streamPayment.createdAt()) .modifiedAt(streamPayment.modifiedAt()) .type(StreamPaymentType.PAYMENT_RECEIVED) .build(); assertThat(streamPayment).isEqualTo(expected); }
@Test public void convertWithClosingFrameOnFulfill() { long amount = 100; StreamPacket streamPacket = StreamPacket.builder() .interledgerPacketType(InterledgerPacketType.PREPARE) .sequence(UnsignedLong.ONE) .prepareAmount(UnsignedLong.valueOf(10)) .addFrames(moneyFrame()) .build(); StreamPacket streamResponsePacket = StreamPacket.builder() .sequence(UnsignedLong.ONE) .interledgerPacketType(InterledgerPacketType.FULFILL) .prepareAmount(UnsignedLong.valueOf(amount)) .addFrames(moneyMaxFrame(), assetDetailsFrame(DENOMINATION)) .addFrames(closeFrame()) .build(); FulfillmentGeneratedEvent event = FulfillmentGeneratedEvent.builder() .preparePacket(preparePacket(amount, streamPacket)) .accountId(ACCOUNT_ID) .denomination(DENOMINATION) .paymentType(StreamPaymentType.PAYMENT_SENT) .fulfillPacket(InterledgerFulfillPacket.builder() .fulfillment(InterledgerFulfillment.of(new byte[32])) .typedData(streamResponsePacket) .build() ) .build(); StreamPayment streamPayment = converter.convert(event); StreamPayment expected = StreamPayment.builder() .assetScale(DENOMINATION.assetScale()) .assetCode(DENOMINATION.assetCode()) .status(StreamPaymentStatus.CLOSED_BY_STREAM) .accountId(ACCOUNT_ID) .amount(BigInteger.valueOf(amount).negate()) .packetCount(1) .deliveredAmount(UnsignedLong.valueOf(amount)) .deliveredAssetScale(DENOMINATION.assetScale()) .deliveredAssetCode(DENOMINATION.assetCode()) .destinationAddress(DESTINATION_ADDRESS) .createdAt(streamPayment.createdAt()) .modifiedAt(streamPayment.modifiedAt()) .type(StreamPaymentType.PAYMENT_SENT) .build(); assertThat(streamPayment).isEqualTo(expected); }
@Test public void convertWithConnectionNewAddressFrame() { long amount = 100; InterledgerAddress source = InterledgerAddress.of("test.source"); StreamPacket streamPacket = StreamPacket.builder() .interledgerPacketType(InterledgerPacketType.PREPARE) .sequence(UnsignedLong.ONE) .prepareAmount(UnsignedLong.valueOf(10)) .addFrames(moneyFrame()) .addFrames(ConnectionNewAddressFrame.builder().sourceAddress(source).build()) .build(); FulfillmentGeneratedEvent event = FulfillmentGeneratedEvent.builder() .preparePacket(preparePacket(amount, streamPacket)) .accountId(ACCOUNT_ID) .denomination(DENOMINATION) .paymentType(StreamPaymentType.PAYMENT_RECEIVED) .fulfillPacket(InterledgerFulfillPacket.builder() .fulfillment(InterledgerFulfillment.of(new byte[32])) .data(new byte[0]) .build() ) .build(); StreamPayment streamPayment = converter.convert(event); StreamPayment expected = StreamPayment.builder() .assetScale(DENOMINATION.assetScale()) .assetCode(DENOMINATION.assetCode()) .status(StreamPaymentStatus.PENDING) .accountId(ACCOUNT_ID) .amount(BigInteger.valueOf(amount)) .packetCount(1) .deliveredAmount(UnsignedLong.valueOf(amount)) .deliveredAssetScale(DENOMINATION.assetScale()) .deliveredAssetCode(DENOMINATION.assetCode()) .destinationAddress(DESTINATION_ADDRESS) .createdAt(streamPayment.createdAt()) .modifiedAt(streamPayment.modifiedAt()) .sourceAddress(source) .type(StreamPaymentType.PAYMENT_RECEIVED) .build(); assertThat(streamPayment).isEqualTo(expected); }
@Test public void convertPaymentSentWithSharedSecret() { SharedSecret sharedSecret = SharedSecret.of(ByteArrayUtils.generate32RandomBytes()); UnsignedLong sentAmount = UnsignedLong.valueOf(20); UnsignedLong deliveredAmount = UnsignedLong.valueOf(15); StreamPacket streamPreparePacket = StreamPacket.builder() .interledgerPacketType(InterledgerPacketType.PREPARE) .sequence(UnsignedLong.ONE) .prepareAmount(UnsignedLong.valueOf(10)) .sharedSecret(sharedSecret) .addFrames(moneyFrame()) .build(); StreamPacket streamResponsePacket = StreamPacket.builder() .sequence(UnsignedLong.ONE) .interledgerPacketType(InterledgerPacketType.FULFILL) .prepareAmount(deliveredAmount) .addFrames(moneyMaxFrame(), assetDetailsFrame(DENOMINATION)) .build(); FulfillmentGeneratedEvent event = FulfillmentGeneratedEvent.builder() .preparePacket(preparePacket(sentAmount.longValue(), streamPreparePacket)) .accountId(ACCOUNT_ID) .denomination(DENOMINATION) .paymentType(StreamPaymentType.PAYMENT_SENT) .fulfillPacket(InterledgerFulfillPacket.builder() .fulfillment(InterledgerFulfillment.of(new byte[32])) .data(toEncrypted(sharedSecret, streamResponsePacket)) .build() ) .build(); StreamPayment streamPayment = converter.convert(event); StreamPayment expected = StreamPayment.builder() .assetScale(DENOMINATION.assetScale()) .assetCode(DENOMINATION.assetCode()) .status(StreamPaymentStatus.PENDING) .accountId(ACCOUNT_ID) .amount(sentAmount.bigIntegerValue().negate()) .packetCount(1) .deliveredAmount(deliveredAmount) .deliveredAssetScale(DENOMINATION.assetScale()) .deliveredAssetCode(DENOMINATION.assetCode()) .destinationAddress(DESTINATION_ADDRESS) .createdAt(streamPayment.createdAt()) .modifiedAt(streamPayment.modifiedAt()) .type(StreamPaymentType.PAYMENT_SENT) .build(); assertThat(streamPayment).isEqualTo(expected); }
@Test public void convertPaymentSentWithTypedData() { SharedSecret sharedSecret = SharedSecret.of(ByteArrayUtils.generate32RandomBytes()); UnsignedLong sentAmount = UnsignedLong.valueOf(20); UnsignedLong deliveredAmount = UnsignedLong.valueOf(20); StreamPacket streamPreparePacket = StreamPacket.builder() .interledgerPacketType(InterledgerPacketType.PREPARE) .sequence(UnsignedLong.ONE) .prepareAmount(UnsignedLong.valueOf(10)) .sharedSecret(sharedSecret) .addFrames(moneyFrame()) .build(); StreamPacket streamResponsePacket = StreamPacket.builder() .sequence(UnsignedLong.ONE) .interledgerPacketType(InterledgerPacketType.FULFILL) .prepareAmount(deliveredAmount) .addFrames(moneyMaxFrame(), assetDetailsFrame(DENOMINATION)) .build(); FulfillmentGeneratedEvent event = FulfillmentGeneratedEvent.builder() .preparePacket(preparePacket(sentAmount.longValue(), streamPreparePacket)) .accountId(ACCOUNT_ID) .denomination(DENOMINATION) .paymentType(StreamPaymentType.PAYMENT_SENT) .fulfillPacket(InterledgerFulfillPacket.builder() .fulfillment(InterledgerFulfillment.of(new byte[32])) .typedData(streamResponsePacket) .build() ) .build(); StreamPayment streamPayment = converter.convert(event); StreamPayment expected = StreamPayment.builder() .assetScale(DENOMINATION.assetScale()) .assetCode(DENOMINATION.assetCode()) .status(StreamPaymentStatus.PENDING) .accountId(ACCOUNT_ID) .amount(sentAmount.bigIntegerValue().negate()) .packetCount(1) .deliveredAmount(deliveredAmount) .deliveredAssetScale(DENOMINATION.assetScale()) .deliveredAssetCode(DENOMINATION.assetCode()) .destinationAddress(DESTINATION_ADDRESS) .createdAt(streamPayment.createdAt()) .modifiedAt(streamPayment.modifiedAt()) .type(StreamPaymentType.PAYMENT_SENT) .build(); assertThat(streamPayment).isEqualTo(expected); } |
FulfillmentGeneratedEventConverter implements Converter<FulfillmentGeneratedEvent, StreamPayment> { @VisibleForTesting protected Optional<SharedSecret> getSharedSecret(InterledgerPacket... packets) { return Lists.newArrayList(packets).stream() .map(InterledgerPacket::typedData) .filter(Optional::isPresent) .map(Optional::get) .filter(typedData -> typedData instanceof StreamPacket) .map(typedData -> (StreamPacket) typedData) .map(StreamPacket::sharedSecret) .filter(Optional::isPresent) .map(Optional::get) .findFirst(); } FulfillmentGeneratedEventConverter(StreamEncryptionService streamEncryptionService,
CodecContext streamCodecContext); @Override StreamPayment convert(FulfillmentGeneratedEvent source); } | @Test public void findSharedSecretInIlpPackets() { final SharedSecret sharedSecret1 = SharedSecret.of(ByteArrayUtils.generate32RandomBytes()); final SharedSecret sharedSecret2 = SharedSecret.of(ByteArrayUtils.generate32RandomBytes()); final SharedSecret sharedSecret3 = SharedSecret.of(ByteArrayUtils.generate32RandomBytes()); assertThat(this.converter.getSharedSecret(new InterledgerPacket[0])).isEmpty(); assertThat(this.converter.getSharedSecret( new InterledgerPacket[] {constructInterledgerPacketWithStreamPacket(Optional.empty())} )).isEmpty(); assertThat(this.converter.getSharedSecret( new InterledgerPacket[] {constructInterledgerPacketWithStreamPacket(Optional.of(sharedSecret1))} )).get().isEqualTo(sharedSecret1); assertThat(this.converter.getSharedSecret( new InterledgerPacket[] { constructInterledgerPacketWithStreamPacket(Optional.empty()), constructInterledgerPacketWithStreamPacket(Optional.empty()), constructInterledgerPacketWithStreamPacket(Optional.empty()) } )).isEmpty(); assertThat(this.converter.getSharedSecret( new InterledgerPacket[] { constructInterledgerPacketWithStreamPacket(Optional.of(sharedSecret1)), constructInterledgerPacketWithStreamPacket(Optional.of(sharedSecret2)), constructInterledgerPacketWithStreamPacket(Optional.of(sharedSecret3)) } )).get().isEqualTo(sharedSecret1); assertThat(this.converter.getSharedSecret( new InterledgerPacket[] { constructInterledgerPacketWithStreamPacket(Optional.of(sharedSecret1)), constructInterledgerPacketWithStreamPacket(Optional.empty()), constructInterledgerPacketWithStreamPacket(Optional.empty()) } )).get().isEqualTo(sharedSecret1); assertThat(this.converter.getSharedSecret( new InterledgerPacket[] { constructInterledgerPacketWithStreamPacket(Optional.empty()), constructInterledgerPacketWithStreamPacket(Optional.of(sharedSecret2)), constructInterledgerPacketWithStreamPacket(Optional.empty()) } )).get().isEqualTo(sharedSecret2); assertThat(this.converter.getSharedSecret( new InterledgerPacket[] { constructInterledgerPacketWithStreamPacket(Optional.empty()), constructInterledgerPacketWithStreamPacket(Optional.empty()), constructInterledgerPacketWithStreamPacket(Optional.of(sharedSecret3)) } )).get().isEqualTo(sharedSecret3); } |
InDatabaseStreamPaymentManager implements StreamPaymentManager { @Override public Optional<StreamPayment> findByAccountIdAndStreamPaymentId(AccountId accountId, String streamPaymentId) { return streamPaymentsRepository.findByAccountIdAndStreamPaymentId(accountId, streamPaymentId) .map(streamPaymentFromEntityConverter::convert); } InDatabaseStreamPaymentManager(StreamPaymentsRepository streamPaymentsRepository,
StreamPaymentFromEntityConverter streamPaymentFromEntityConverter,
StreamPaymentToEntityConverter streamPaymentToEntityConverter); @Override List<StreamPayment> findByAccountId(AccountId accountId, PageRequest pageRequest); @Override Optional<StreamPayment> findByAccountIdAndStreamPaymentId(AccountId accountId, String streamPaymentId); @Override void merge(StreamPayment streamPayment); } | @Test public void findByAccountIdAndStreamPaymentId() { StreamPayment trx1 = transactionBuilder().build(); when(mockRepo.findByAccountIdAndStreamPaymentId(trx1.accountId(), trx1.streamPaymentId())) .thenReturn(Optional.of(streamPaymentToEntityConverter.convert(trx1))); assertThat(transactionManager.findByAccountIdAndStreamPaymentId(trx1.accountId(), trx1.streamPaymentId())) .isEqualTo(Optional.of(trx1)); } |
InDatabaseStreamPaymentManager implements StreamPaymentManager { @Override public List<StreamPayment> findByAccountId(AccountId accountId, PageRequest pageRequest) { return streamPaymentsRepository.findByAccountIdOrderByCreatedDateDesc(accountId, pageRequest) .stream() .map(streamPaymentFromEntityConverter::convert) .collect(Collectors.toList()); } InDatabaseStreamPaymentManager(StreamPaymentsRepository streamPaymentsRepository,
StreamPaymentFromEntityConverter streamPaymentFromEntityConverter,
StreamPaymentToEntityConverter streamPaymentToEntityConverter); @Override List<StreamPayment> findByAccountId(AccountId accountId, PageRequest pageRequest); @Override Optional<StreamPayment> findByAccountIdAndStreamPaymentId(AccountId accountId, String streamPaymentId); @Override void merge(StreamPayment streamPayment); } | @Test public void findByAccountId() { StreamPayment trx1 = transactionBuilder().build(); StreamPayment trx2 = transactionBuilder().build(); when(mockRepo.findByAccountIdOrderByCreatedDateDesc(eq(trx1.accountId()), any())) .thenReturn(Lists.newArrayList(streamPaymentToEntityConverter.convert(trx1), streamPaymentToEntityConverter.convert(trx2))); assertThat(transactionManager.findByAccountId(trx1.accountId(), PageRequest.of(0, 100))) .isEqualTo(Lists.newArrayList(trx1, trx2)); } |
InDatabaseStreamPaymentManager implements StreamPaymentManager { @Override public void merge(StreamPayment streamPayment) { streamPaymentsRepository.upsertAmounts(streamPaymentToEntityConverter.convert(streamPayment)); streamPayment.sourceAddress().ifPresent(sourceAddress -> { streamPaymentsRepository.updateSourceAddress(streamPayment.accountId(), streamPayment.streamPaymentId(), sourceAddress.getValue()); }); streamPayment.deliveredAssetScale().ifPresent(assetScale -> { streamPaymentsRepository.udpdateDeliveredDenomination(streamPayment.accountId(), streamPayment.streamPaymentId(), streamPayment.deliveredAssetCode().orElse("unknown"), assetScale); }); if (!streamPayment.status().equals(StreamPaymentStatus.PENDING)) { streamPaymentsRepository.updateStatus(streamPayment.accountId(), streamPayment.streamPaymentId(), streamPayment.status()); } } InDatabaseStreamPaymentManager(StreamPaymentsRepository streamPaymentsRepository,
StreamPaymentFromEntityConverter streamPaymentFromEntityConverter,
StreamPaymentToEntityConverter streamPaymentToEntityConverter); @Override List<StreamPayment> findByAccountId(AccountId accountId, PageRequest pageRequest); @Override Optional<StreamPayment> findByAccountIdAndStreamPaymentId(AccountId accountId, String streamPaymentId); @Override void merge(StreamPayment streamPayment); } | @Test public void mergePending() { StreamPayment trx = transactionBuilder().build(); transactionManager.merge(trx); verify(mockRepo, times(1)).upsertAmounts(streamPaymentToEntityConverter.convert(trx)); verifyNoMoreInteractions(mockRepo); }
@Test public void mergeAndUpdateStatus() { StreamPayment trx = transactionBuilder() .status(StreamPaymentStatus.CLOSED_BY_STREAM) .build(); transactionManager.merge(trx); verify(mockRepo, times(1)).upsertAmounts(streamPaymentToEntityConverter.convert(trx)); verify(mockRepo, times(1)).updateStatus(trx.accountId(), trx.streamPaymentId(), trx.status()); verifyNoMoreInteractions(mockRepo); }
@Test public void mergeAndUpdateSourceAddress() { InterledgerAddress source = InterledgerAddress.of("test.sender"); StreamPayment trx = transactionBuilder() .sourceAddress(source) .build(); transactionManager.merge(trx); verify(mockRepo, times(1)).upsertAmounts(streamPaymentToEntityConverter.convert(trx)); verify(mockRepo, times(1)).updateSourceAddress(trx.accountId(), trx.streamPaymentId(), source.getValue()); verifyNoMoreInteractions(mockRepo); }
@Test public void mergeAndUpdateDeliveredDetails() { String assetCode = "XRP"; short assetScale = 9; StreamPayment trx = transactionBuilder() .deliveredAssetScale(assetScale) .deliveredAssetCode(assetCode) .build(); transactionManager.merge(trx); verify(mockRepo, times(1)).upsertAmounts(streamPaymentToEntityConverter.convert(trx)); verify(mockRepo, times(1)).udpdateDeliveredDenomination(trx.accountId(), trx.streamPaymentId(), assetCode, assetScale); verifyNoMoreInteractions(mockRepo); } |
DefaultSettlementService implements SettlementService { @Override public SettlementQuantity onIncomingSettlementPayment( final String idempotencyKey, final SettlementEngineAccountId settlementEngineAccountId, final SettlementQuantity incomingSettlementInSettlementUnits ) { Objects.requireNonNull(idempotencyKey, "idempotencyKey must not be null"); Objects.requireNonNull(settlementEngineAccountId, "settlementEngineAccountId must not be null"); Objects.requireNonNull(incomingSettlementInSettlementUnits, "incomingSettlementInSettlementUnits must not be null"); final AccountSettings accountSettings = this.accountSettingsRepository .findBySettlementEngineAccountIdWithConversion(settlementEngineAccountId) .orElseThrow(() -> { eventBus.post(IncomingSettlementFailedEvent.builder() .idempotencyKey(idempotencyKey) .settlementEngineAccountId(settlementEngineAccountId) .incomingSettlementInSettlementUnits(incomingSettlementInSettlementUnits)); return new AccountBySettlementEngineAccountNotFoundProblem(settlementEngineAccountId); }); try { final BigInteger settlementQuantityToAdjustInClearingLayer = NumberScalingUtils.translate( incomingSettlementInSettlementUnits.amount(), incomingSettlementInSettlementUnits.scale(), accountSettings.assetScale() ); this.balanceTracker.updateBalanceForIncomingSettlement( idempotencyKey, accountSettings.accountId(), settlementQuantityToAdjustInClearingLayer.longValue() ); final SettlementQuantity settledQuantity = SettlementQuantity.builder() .amount(settlementQuantityToAdjustInClearingLayer) .scale(accountSettings.assetScale()) .build(); eventBus.post(IncomingSettlementSucceededEvent.builder() .accountSettings(accountSettings) .idempotencyKey(idempotencyKey) .settlementEngineAccountId(settlementEngineAccountId) .incomingSettlementInSettlementUnits(incomingSettlementInSettlementUnits) .processedQuantity(settledQuantity) .build()); return settledQuantity; } catch (Exception e) { final SettlementServiceException settlementServiceException = new SettlementServiceException(e, accountSettings.accountId(), settlementEngineAccountId); eventBus.post(IncomingSettlementFailedEvent.builder() .accountSettings(accountSettings) .idempotencyKey(idempotencyKey) .settlementEngineAccountId(settlementEngineAccountId) .incomingSettlementInSettlementUnits(incomingSettlementInSettlementUnits) .settlementServiceException(settlementServiceException) .build()); throw settlementServiceException; } } DefaultSettlementService(
final BalanceTracker balanceTracker,
final LinkManager linkManager,
final AccountSettingsRepository accountSettingsRepository,
final SettlementEngineClient settlementEngineClient,
final EventBus eventBus
); @Override SettlementQuantity onIncomingSettlementPayment(
final String idempotencyKey,
final SettlementEngineAccountId settlementEngineAccountId,
final SettlementQuantity incomingSettlementInSettlementUnits
); @Override byte[] onLocalSettlementMessage(
final SettlementEngineAccountId settlementEngineAccountId, final byte[] message
); @Override byte[] onSettlementMessageFromPeer(
final AccountSettings accountSettings, final byte[] messageFromPeerSettlementEngine
); @Override SettlementQuantity initiateLocalSettlement(
final String idempotencyKey,
final AccountSettings accountSettings,
final SettlementQuantity settlementQuantityInClearingUnits
); } | @Test public void onLocalSettlementPaymentWithNullIdempotenceId() { expectedException.expect(NullPointerException.class); expectedException.expectMessage("idempotencyKey must not be null"); settlementService.onIncomingSettlementPayment(null, SETTLEMENT_ACCOUNT_ID, INCOMING_SETTLEMENT); }
@Test public void onLocalSettlementPaymentWithNullAccountId() { expectedException.expect(NullPointerException.class); expectedException.expectMessage("settlementEngineAccountId must not be null"); settlementService.onIncomingSettlementPayment(UUID.randomUUID().toString(), null, INCOMING_SETTLEMENT); }
@Test public void onLocalSettlementPaymentWithNullQuantity() { expectedException.expect(NullPointerException.class); expectedException.expectMessage("incomingSettlementInSettlementUnits must not be null"); settlementService.onIncomingSettlementPayment(UUID.randomUUID().toString(), SETTLEMENT_ACCOUNT_ID, null); }
@Test public void onLocalSettlementPaymentWhenAccountNotFound() { expectedException.expect(InvalidAccountIdProblem.class); expectedException .expectMessage("AccountIds may only contain the following characters: 'a–z', '0–9', '-', '_', or '~'"); when(accountSettingsRepositoryMock.findBySettlementEngineAccountId(SETTLEMENT_ACCOUNT_ID)) .thenReturn(Optional.empty()); settlementService .onIncomingSettlementPayment(UUID.randomUUID().toString(), SETTLEMENT_ACCOUNT_ID, INCOMING_SETTLEMENT); }
@Test public void onLocalSettlementPayment() { String idempotencyKey = UUID.randomUUID().toString(); final AccountSettings accountSettings = AccountSettings.builder() .accountId(ACCOUNT_ID) .accountRelationship(AccountRelationship.PEER) .assetCode("USD") .assetScale(9) .linkType(LoopbackLink.LINK_TYPE) .settlementEngineDetails( SettlementEngineDetails.builder() .settlementEngineAccountId(SettlementEngineAccountId.of(ACCOUNT_ID.value())) .baseUrl(HttpUrl.parse("https: .build() ) .build(); when(accountSettingsRepositoryMock.findBySettlementEngineAccountIdWithConversion(SETTLEMENT_ACCOUNT_ID)) .thenReturn(Optional.of(accountSettings)); SettlementQuantity expectedClearedSettlementQuantity = SettlementQuantity.builder() .amount(BigInteger.valueOf(1000L)) .scale(9) .build(); SettlementQuantity actualClearedSettlementQuantity = settlementService.onIncomingSettlementPayment(idempotencyKey, SETTLEMENT_ACCOUNT_ID, INCOMING_SETTLEMENT); assertThat(actualClearedSettlementQuantity).isEqualTo(expectedClearedSettlementQuantity); verify(accountSettingsRepositoryMock).findBySettlementEngineAccountIdWithConversion(SETTLEMENT_ACCOUNT_ID); verify(balanceTrackerMock).updateBalanceForIncomingSettlement( idempotencyKey, ACCOUNT_ID, expectedClearedSettlementQuantity.amount().longValue() ); verifyNoMoreInteractions(balanceTrackerMock); verifyNoMoreInteractions(accountSettingsRepositoryMock); } |
SpspController { @VisibleForTesting protected final Optional<String> cleanupSpspUrlPath(String spspUrlPath) { String cleanedUpSpspUrlPath = spspUrlPath; if (StringUtils.isBlank(cleanedUpSpspUrlPath) || StringUtils.equals(cleanedUpSpspUrlPath, "/")) { return Optional.empty(); } else { if (!cleanedUpSpspUrlPath.startsWith("/")) { cleanedUpSpspUrlPath = "/" + cleanedUpSpspUrlPath; } if (cleanedUpSpspUrlPath.endsWith("/")) { cleanedUpSpspUrlPath = cleanedUpSpspUrlPath.substring(0, cleanedUpSpspUrlPath.length() - 1); } cleanedUpSpspUrlPath = cleanedUpSpspUrlPath.replaceAll(" return Optional.ofNullable(cleanedUpSpspUrlPath); } } SpspController(
final Supplier<ConnectorSettings> connectorSettingsSupplier,
final StreamReceiver streamReceiver,
@Value("${" + SPSP__URL_PATH + ":}") final String spspUrlPath
); @RequestMapping( path = "/**", method = RequestMethod.GET, produces = {APPLICATION_SPSP4_JSON_VALUE, APPLICATION_JSON_VALUE, MediaTypes.PROBLEM_VALUE} ) ResponseEntity<StreamConnectionDetails> getSpspResponse(final HttpServletRequest httpServletRequest); } | @Test public void cleanupSpspUrlPathWithNullBlankEmpty() { assertThat(spspController.cleanupSpspUrlPath(null)).isEmpty(); assertThat(spspController.cleanupSpspUrlPath("")).isEmpty(); assertThat(spspController.cleanupSpspUrlPath(" ")).isEmpty(); assertThat(spspController.cleanupSpspUrlPath("/")).isEmpty(); }
@Test public void cleanupSpspUrlPathWithVariants() { assertThat(spspController.cleanupSpspUrlPath("p")).get().isEqualTo("/p"); assertThat(spspController.cleanupSpspUrlPath("/p")).get().isEqualTo("/p"); assertThat(spspController.cleanupSpspUrlPath("p/")).get().isEqualTo("/p"); assertThat(spspController.cleanupSpspUrlPath("/p/")).get().isEqualTo("/p"); assertThat(spspController.cleanupSpspUrlPath("/p/foo/")).get().isEqualTo("/p/foo"); assertThat(spspController.cleanupSpspUrlPath("p/foo")).get().isEqualTo("/p/foo"); assertThat(spspController.cleanupSpspUrlPath("/p/foo/")).get().isEqualTo("/p/foo"); } |
NumberScalingUtils { public static BigInteger translate( final BigInteger sourceAmount, final int sourceScale, final int destinationScale ) { Objects.requireNonNull(sourceAmount, "sourceAmount must not be null"); Preconditions.checkArgument(sourceAmount.compareTo(BigInteger.ZERO) >= 0, "sourceAmount must be positive"); Preconditions.checkArgument(sourceScale >= 0, "sourceScale must be positive"); Preconditions.checkArgument(destinationScale >= 0, "destinationScale must be positive"); final int scaleDifference = destinationScale - sourceScale; final BigInteger scaledAmount = scaleDifference > 0 ? sourceAmount.multiply(BigInteger.TEN.pow(scaleDifference)) : sourceAmount.divide((BigInteger.TEN.pow(scaleDifference * -1))); return scaledAmount; } static BigInteger translate(
final BigInteger sourceAmount, final int sourceScale, final int destinationScale
); } | @Test(expected = NullPointerException.class) public void translateWithNullSourceQuantity() { try { NumberScalingUtils.translate(null, 1, 2); fail("Should have thrown an NPE"); } catch (NullPointerException e) { assertThat(e.getMessage()).isEqualTo("sourceAmount must not be null"); throw e; } }
@Test(expected = IllegalArgumentException.class) public void translateWithNegativeSourceScale() { try { NumberScalingUtils.translate(BigInteger.ZERO, -11, 2); fail("Should have thrown an NPE"); } catch (NullPointerException e) { assertThat(e.getMessage()).isEqualTo("sourceScale must not be negative"); throw e; } }
@Test(expected = IllegalArgumentException.class) public void translateWithNegativeDestinationScale() { try { NumberScalingUtils.translate(BigInteger.ZERO, 1, -1); fail("Should have thrown an NPE"); } catch (NullPointerException e) { assertThat(e.getMessage()).isEqualTo("destinationScale must not be negative"); throw e; } }
@Test public void translate() { assertThat(NumberScalingUtils.translate( sourceSettlementQuantity.amount(), sourceSettlementQuantity.scale(), expectedSettlementQuantity.scale() )).as(description).isEqualTo(expectedSettlementQuantity.amount()); } |
AccountSettingsLoadingCache implements AccountSettingsCache { @Subscribe @SuppressWarnings("PMD.UnusedPublicMethod") public void _handleAccountUpdated(AccountUpdatedEvent event) { this.accountSettingsCache.invalidate(event.accountId()); } @VisibleForTesting AccountSettingsLoadingCache(final AccountSettingsRepository accountSettingsRepository,
final EventBus eventBus); AccountSettingsLoadingCache(
final AccountSettingsRepository accountSettingsRepository,
final Cache<AccountId, Optional<AccountSettings>> accountSettingsCache,
final EventBus eventBus
); Optional<AccountSettings> getAccount(final AccountId accountId); AccountSettings safeGetAccountId(final AccountId accountId); @Subscribe @SuppressWarnings("PMD.UnusedPublicMethod") void _handleAccountUpdated(AccountUpdatedEvent event); } | @Test public void accountUpdatedEventInvalidates() { accountSettingsLoadingCache._handleAccountUpdated( AccountUpdatedEvent.builder() .accountId(AccountId.of("ricketycricket")) .build() ); verify(accountSettingsCache, times(1)).invalidate(AccountId.of("ricketycricket")); } |
PrometheusMetricsService implements MetricsService { @Override public void trackIncomingPacketPrepared(AccountSettings accountSettings, InterledgerPreparePacket preparePacket) { Objects.requireNonNull(accountSettings); Objects.requireNonNull(preparePacket); PrometheusCollectors.incomingPackets.labels( PacketStatusResult.PREPARED.name(), EMPTY_REJECT_CODE, accountSettings.accountId().value(), accountSettings.assetCode(), stringify(accountSettings.assetScale()) ).inc(); } @Override void trackIncomingPacketPrepared(AccountSettings accountSettings, InterledgerPreparePacket preparePacket); @Override void trackIncomingPacketFulfilled(
final AccountSettings accountSettings, final InterledgerFulfillPacket fulfillPacket
); @Override void trackIncomingPacketRejected(
final AccountSettings accountSettings, final InterledgerRejectPacket rejectPacket
); @Override void trackIncomingPacketFailed(final AccountSettings accountSettings); @Override void trackOutgoingPacketPrepared(AccountSettings accountSettings, InterledgerPreparePacket preparePacket); @Override void trackOutgoingPacketFulfilled(
final AccountSettings accountSettings, final InterledgerFulfillPacket fulfillPacket
); @Override void trackOutgoingPacketRejected(
final AccountSettings accountSettings, final InterledgerRejectPacket rejectPacket
); @Override void trackOutgoingPacketFailed(final AccountSettings accountSettings); @Override void trackNumRateLimitedPackets(final AccountSettings accountSettings); @Override void trackIncomingSettlementSucceeded(IncomingSettlementSucceededEvent event); @Override void trackIncomingSettlementFailed(IncomingSettlementFailedEvent event); @Override void trackOutgoingSettlementInitiationSucceeded(final OutgoingSettlementInitiationSucceededEvent event); @Override void trackOutgoingSettlementInitiationFailed(OutgoingSettlementInitiationFailedEvent event); } | @Test public void trackIncomingPacketPrepared() { final Counter counter = PrometheusCollectors.incomingPackets; assertThat(sum(counter)).isEqualTo(0); for (int i = 0; i < 100; i++) { metricsService.trackIncomingPacketPrepared(accountSettings(), preparePacket()); assertThat(sum(counter, PacketStatusResult.PREPARED.name())).isEqualTo(i + 1); assertThat(sum(counter, PacketStatusResult.FULFILLED.name())).isEqualTo(0); assertThat(sum(counter, PacketStatusResult.REJECTED.name())).isEqualTo(0); assertThat(sum(counter, PacketStatusResult.FAILED.name())).isEqualTo(0); } } |
PrometheusMetricsService implements MetricsService { @Override public void trackIncomingPacketFulfilled( final AccountSettings accountSettings, final InterledgerFulfillPacket fulfillPacket ) { Objects.requireNonNull(accountSettings); Objects.requireNonNull(fulfillPacket); PrometheusCollectors.incomingPackets.labels( PacketStatusResult.FULFILLED.name(), EMPTY_REJECT_CODE, accountSettings.accountId().value(), accountSettings.assetCode(), stringify(accountSettings.assetScale()) ).inc(); } @Override void trackIncomingPacketPrepared(AccountSettings accountSettings, InterledgerPreparePacket preparePacket); @Override void trackIncomingPacketFulfilled(
final AccountSettings accountSettings, final InterledgerFulfillPacket fulfillPacket
); @Override void trackIncomingPacketRejected(
final AccountSettings accountSettings, final InterledgerRejectPacket rejectPacket
); @Override void trackIncomingPacketFailed(final AccountSettings accountSettings); @Override void trackOutgoingPacketPrepared(AccountSettings accountSettings, InterledgerPreparePacket preparePacket); @Override void trackOutgoingPacketFulfilled(
final AccountSettings accountSettings, final InterledgerFulfillPacket fulfillPacket
); @Override void trackOutgoingPacketRejected(
final AccountSettings accountSettings, final InterledgerRejectPacket rejectPacket
); @Override void trackOutgoingPacketFailed(final AccountSettings accountSettings); @Override void trackNumRateLimitedPackets(final AccountSettings accountSettings); @Override void trackIncomingSettlementSucceeded(IncomingSettlementSucceededEvent event); @Override void trackIncomingSettlementFailed(IncomingSettlementFailedEvent event); @Override void trackOutgoingSettlementInitiationSucceeded(final OutgoingSettlementInitiationSucceededEvent event); @Override void trackOutgoingSettlementInitiationFailed(OutgoingSettlementInitiationFailedEvent event); } | @Test public void trackIncomingPacketFulfilled() { final Counter counter = PrometheusCollectors.incomingPackets; assertThat(sum(counter)).isEqualTo(0); for (int i = 0; i < 100; i++) { metricsService.trackIncomingPacketFulfilled(accountSettings(), fulfillPacket()); assertThat(sum(counter, PacketStatusResult.PREPARED.name())).isEqualTo(0); assertThat(sum(counter, PacketStatusResult.FULFILLED.name())).isEqualTo(i + 1); assertThat(sum(counter, PacketStatusResult.REJECTED.name())).isEqualTo(0); assertThat(sum(counter, PacketStatusResult.FAILED.name())).isEqualTo(0); } } |
PrometheusMetricsService implements MetricsService { @Override public void trackIncomingPacketRejected( final AccountSettings accountSettings, final InterledgerRejectPacket rejectPacket ) { Objects.requireNonNull(accountSettings); Objects.requireNonNull(rejectPacket); PrometheusCollectors.incomingPackets.labels( PacketStatusResult.REJECTED.name(), rejectPacket.getCode().getCode(), accountSettings.accountId().value(), accountSettings.assetCode(), stringify(accountSettings.assetScale()) ).inc(); } @Override void trackIncomingPacketPrepared(AccountSettings accountSettings, InterledgerPreparePacket preparePacket); @Override void trackIncomingPacketFulfilled(
final AccountSettings accountSettings, final InterledgerFulfillPacket fulfillPacket
); @Override void trackIncomingPacketRejected(
final AccountSettings accountSettings, final InterledgerRejectPacket rejectPacket
); @Override void trackIncomingPacketFailed(final AccountSettings accountSettings); @Override void trackOutgoingPacketPrepared(AccountSettings accountSettings, InterledgerPreparePacket preparePacket); @Override void trackOutgoingPacketFulfilled(
final AccountSettings accountSettings, final InterledgerFulfillPacket fulfillPacket
); @Override void trackOutgoingPacketRejected(
final AccountSettings accountSettings, final InterledgerRejectPacket rejectPacket
); @Override void trackOutgoingPacketFailed(final AccountSettings accountSettings); @Override void trackNumRateLimitedPackets(final AccountSettings accountSettings); @Override void trackIncomingSettlementSucceeded(IncomingSettlementSucceededEvent event); @Override void trackIncomingSettlementFailed(IncomingSettlementFailedEvent event); @Override void trackOutgoingSettlementInitiationSucceeded(final OutgoingSettlementInitiationSucceededEvent event); @Override void trackOutgoingSettlementInitiationFailed(OutgoingSettlementInitiationFailedEvent event); } | @Test public void trackIncomingPacketRejected() { final Counter counter = PrometheusCollectors.incomingPackets; assertThat(sum(counter)).isEqualTo(0); for (int i = 0; i < 100; i++) { metricsService.trackIncomingPacketRejected(accountSettings(), rejectPacket()); assertThat(sum(counter, PacketStatusResult.PREPARED.name())).isEqualTo(0); assertThat(sum(counter, PacketStatusResult.FULFILLED.name())).isEqualTo(0); assertThat(sum(counter, PacketStatusResult.REJECTED.name())).isEqualTo(i + 1); assertThat(sum(counter, PacketStatusResult.FAILED.name())).isEqualTo(0); } } |
PrometheusMetricsService implements MetricsService { @Override public void trackIncomingPacketFailed(final AccountSettings accountSettings) { Objects.requireNonNull(accountSettings); PrometheusCollectors.incomingPackets.labels( PacketStatusResult.FAILED.name(), EMPTY_REJECT_CODE, accountSettings.accountId().value(), accountSettings.assetCode(), stringify(accountSettings.assetScale()) ).inc(); } @Override void trackIncomingPacketPrepared(AccountSettings accountSettings, InterledgerPreparePacket preparePacket); @Override void trackIncomingPacketFulfilled(
final AccountSettings accountSettings, final InterledgerFulfillPacket fulfillPacket
); @Override void trackIncomingPacketRejected(
final AccountSettings accountSettings, final InterledgerRejectPacket rejectPacket
); @Override void trackIncomingPacketFailed(final AccountSettings accountSettings); @Override void trackOutgoingPacketPrepared(AccountSettings accountSettings, InterledgerPreparePacket preparePacket); @Override void trackOutgoingPacketFulfilled(
final AccountSettings accountSettings, final InterledgerFulfillPacket fulfillPacket
); @Override void trackOutgoingPacketRejected(
final AccountSettings accountSettings, final InterledgerRejectPacket rejectPacket
); @Override void trackOutgoingPacketFailed(final AccountSettings accountSettings); @Override void trackNumRateLimitedPackets(final AccountSettings accountSettings); @Override void trackIncomingSettlementSucceeded(IncomingSettlementSucceededEvent event); @Override void trackIncomingSettlementFailed(IncomingSettlementFailedEvent event); @Override void trackOutgoingSettlementInitiationSucceeded(final OutgoingSettlementInitiationSucceededEvent event); @Override void trackOutgoingSettlementInitiationFailed(OutgoingSettlementInitiationFailedEvent event); } | @Test public void trackIncomingPacketFailed() { final Counter counter = PrometheusCollectors.incomingPackets; assertThat(sum(counter)).isEqualTo(0); for (int i = 0; i < 100; i++) { metricsService.trackIncomingPacketFailed(accountSettings()); assertThat(sum(counter, PacketStatusResult.PREPARED.name())).isEqualTo(0); assertThat(sum(counter, PacketStatusResult.FULFILLED.name())).isEqualTo(0); assertThat(sum(counter, PacketStatusResult.REJECTED.name())).isEqualTo(0); assertThat(sum(counter, PacketStatusResult.FAILED.name())).isEqualTo(i + 1); } } |
PrometheusMetricsService implements MetricsService { @Override public void trackOutgoingPacketPrepared(AccountSettings accountSettings, InterledgerPreparePacket preparePacket) { Objects.requireNonNull(accountSettings); Objects.requireNonNull(preparePacket); PrometheusCollectors.outgoingPackets.labels( PacketStatusResult.PREPARED.name(), EMPTY_REJECT_CODE, accountSettings.accountId().value(), accountSettings.assetCode(), stringify(accountSettings.assetScale()) ).inc(); } @Override void trackIncomingPacketPrepared(AccountSettings accountSettings, InterledgerPreparePacket preparePacket); @Override void trackIncomingPacketFulfilled(
final AccountSettings accountSettings, final InterledgerFulfillPacket fulfillPacket
); @Override void trackIncomingPacketRejected(
final AccountSettings accountSettings, final InterledgerRejectPacket rejectPacket
); @Override void trackIncomingPacketFailed(final AccountSettings accountSettings); @Override void trackOutgoingPacketPrepared(AccountSettings accountSettings, InterledgerPreparePacket preparePacket); @Override void trackOutgoingPacketFulfilled(
final AccountSettings accountSettings, final InterledgerFulfillPacket fulfillPacket
); @Override void trackOutgoingPacketRejected(
final AccountSettings accountSettings, final InterledgerRejectPacket rejectPacket
); @Override void trackOutgoingPacketFailed(final AccountSettings accountSettings); @Override void trackNumRateLimitedPackets(final AccountSettings accountSettings); @Override void trackIncomingSettlementSucceeded(IncomingSettlementSucceededEvent event); @Override void trackIncomingSettlementFailed(IncomingSettlementFailedEvent event); @Override void trackOutgoingSettlementInitiationSucceeded(final OutgoingSettlementInitiationSucceededEvent event); @Override void trackOutgoingSettlementInitiationFailed(OutgoingSettlementInitiationFailedEvent event); } | @Test public void trackOutgoingPacketPrepared() { final Counter counter = PrometheusCollectors.outgoingPackets; assertThat(sum(counter)).isEqualTo(0); for (int i = 0; i < 100; i++) { metricsService.trackOutgoingPacketPrepared(accountSettings(), preparePacket()); assertThat(sum(counter, PacketStatusResult.PREPARED.name())).isEqualTo(i + 1); assertThat(sum(counter, PacketStatusResult.FULFILLED.name())).isEqualTo(0); assertThat(sum(counter, PacketStatusResult.REJECTED.name())).isEqualTo(0); assertThat(sum(counter, PacketStatusResult.FAILED.name())).isEqualTo(0); } } |
PrometheusMetricsService implements MetricsService { @Override public void trackOutgoingPacketFulfilled( final AccountSettings accountSettings, final InterledgerFulfillPacket fulfillPacket ) { Objects.requireNonNull(accountSettings); Objects.requireNonNull(fulfillPacket); PrometheusCollectors.outgoingPackets.labels( PacketStatusResult.FULFILLED.name(), EMPTY_REJECT_CODE, accountSettings.accountId().value(), accountSettings.assetCode(), stringify(accountSettings.assetScale()) ).inc(); } @Override void trackIncomingPacketPrepared(AccountSettings accountSettings, InterledgerPreparePacket preparePacket); @Override void trackIncomingPacketFulfilled(
final AccountSettings accountSettings, final InterledgerFulfillPacket fulfillPacket
); @Override void trackIncomingPacketRejected(
final AccountSettings accountSettings, final InterledgerRejectPacket rejectPacket
); @Override void trackIncomingPacketFailed(final AccountSettings accountSettings); @Override void trackOutgoingPacketPrepared(AccountSettings accountSettings, InterledgerPreparePacket preparePacket); @Override void trackOutgoingPacketFulfilled(
final AccountSettings accountSettings, final InterledgerFulfillPacket fulfillPacket
); @Override void trackOutgoingPacketRejected(
final AccountSettings accountSettings, final InterledgerRejectPacket rejectPacket
); @Override void trackOutgoingPacketFailed(final AccountSettings accountSettings); @Override void trackNumRateLimitedPackets(final AccountSettings accountSettings); @Override void trackIncomingSettlementSucceeded(IncomingSettlementSucceededEvent event); @Override void trackIncomingSettlementFailed(IncomingSettlementFailedEvent event); @Override void trackOutgoingSettlementInitiationSucceeded(final OutgoingSettlementInitiationSucceededEvent event); @Override void trackOutgoingSettlementInitiationFailed(OutgoingSettlementInitiationFailedEvent event); } | @Test public void trackOutgoingPacketFulfilled() { final Counter counter = PrometheusCollectors.outgoingPackets; assertThat(sum(counter)).isEqualTo(0); for (int i = 0; i < 100; i++) { metricsService.trackOutgoingPacketFulfilled(accountSettings(), fulfillPacket()); assertThat(sum(counter, PacketStatusResult.PREPARED.name())).isEqualTo(0); assertThat(sum(counter, PacketStatusResult.FULFILLED.name())).isEqualTo(i + 1); assertThat(sum(counter, PacketStatusResult.REJECTED.name())).isEqualTo(0); assertThat(sum(counter, PacketStatusResult.FAILED.name())).isEqualTo(0); } } |
PrometheusMetricsService implements MetricsService { @Override public void trackOutgoingPacketRejected( final AccountSettings accountSettings, final InterledgerRejectPacket rejectPacket ) { Objects.requireNonNull(accountSettings); Objects.requireNonNull(rejectPacket); PrometheusCollectors.outgoingPackets.labels( PacketStatusResult.REJECTED.name(), rejectPacket.getCode().getCode(), accountSettings.accountId().value(), accountSettings.assetCode(), stringify(accountSettings.assetScale()) ).inc(); } @Override void trackIncomingPacketPrepared(AccountSettings accountSettings, InterledgerPreparePacket preparePacket); @Override void trackIncomingPacketFulfilled(
final AccountSettings accountSettings, final InterledgerFulfillPacket fulfillPacket
); @Override void trackIncomingPacketRejected(
final AccountSettings accountSettings, final InterledgerRejectPacket rejectPacket
); @Override void trackIncomingPacketFailed(final AccountSettings accountSettings); @Override void trackOutgoingPacketPrepared(AccountSettings accountSettings, InterledgerPreparePacket preparePacket); @Override void trackOutgoingPacketFulfilled(
final AccountSettings accountSettings, final InterledgerFulfillPacket fulfillPacket
); @Override void trackOutgoingPacketRejected(
final AccountSettings accountSettings, final InterledgerRejectPacket rejectPacket
); @Override void trackOutgoingPacketFailed(final AccountSettings accountSettings); @Override void trackNumRateLimitedPackets(final AccountSettings accountSettings); @Override void trackIncomingSettlementSucceeded(IncomingSettlementSucceededEvent event); @Override void trackIncomingSettlementFailed(IncomingSettlementFailedEvent event); @Override void trackOutgoingSettlementInitiationSucceeded(final OutgoingSettlementInitiationSucceededEvent event); @Override void trackOutgoingSettlementInitiationFailed(OutgoingSettlementInitiationFailedEvent event); } | @Test public void trackOutgoingPacketRejected() { final Counter counter = PrometheusCollectors.outgoingPackets; assertThat(sum(counter)).isEqualTo(0); for (int i = 0; i < 100; i++) { metricsService.trackOutgoingPacketRejected(accountSettings(), rejectPacket()); assertThat(sum(counter, PacketStatusResult.PREPARED.name())).isEqualTo(0); assertThat(sum(counter, PacketStatusResult.FULFILLED.name())).isEqualTo(0); assertThat(sum(counter, PacketStatusResult.REJECTED.name())).isEqualTo(i + 1); assertThat(sum(counter, PacketStatusResult.FAILED.name())).isEqualTo(0); } } |
PrometheusMetricsService implements MetricsService { @Override public void trackOutgoingPacketFailed(final AccountSettings accountSettings) { Objects.requireNonNull(accountSettings); PrometheusCollectors.outgoingPackets.labels( PacketStatusResult.FAILED.name(), EMPTY_REJECT_CODE, accountSettings.accountId().value(), accountSettings.assetCode(), stringify(accountSettings.assetScale()) ).inc(); } @Override void trackIncomingPacketPrepared(AccountSettings accountSettings, InterledgerPreparePacket preparePacket); @Override void trackIncomingPacketFulfilled(
final AccountSettings accountSettings, final InterledgerFulfillPacket fulfillPacket
); @Override void trackIncomingPacketRejected(
final AccountSettings accountSettings, final InterledgerRejectPacket rejectPacket
); @Override void trackIncomingPacketFailed(final AccountSettings accountSettings); @Override void trackOutgoingPacketPrepared(AccountSettings accountSettings, InterledgerPreparePacket preparePacket); @Override void trackOutgoingPacketFulfilled(
final AccountSettings accountSettings, final InterledgerFulfillPacket fulfillPacket
); @Override void trackOutgoingPacketRejected(
final AccountSettings accountSettings, final InterledgerRejectPacket rejectPacket
); @Override void trackOutgoingPacketFailed(final AccountSettings accountSettings); @Override void trackNumRateLimitedPackets(final AccountSettings accountSettings); @Override void trackIncomingSettlementSucceeded(IncomingSettlementSucceededEvent event); @Override void trackIncomingSettlementFailed(IncomingSettlementFailedEvent event); @Override void trackOutgoingSettlementInitiationSucceeded(final OutgoingSettlementInitiationSucceededEvent event); @Override void trackOutgoingSettlementInitiationFailed(OutgoingSettlementInitiationFailedEvent event); } | @Test public void trackOutgoingPacketFailed() { final Counter counter = PrometheusCollectors.outgoingPackets; assertThat(sum(counter)).isEqualTo(0); for (int i = 0; i < 100; i++) { metricsService.trackOutgoingPacketFailed(accountSettings()); assertThat(sum(counter, PacketStatusResult.PREPARED.name())).isEqualTo(0); assertThat(sum(counter, PacketStatusResult.FULFILLED.name())).isEqualTo(0); assertThat(sum(counter, PacketStatusResult.REJECTED.name())).isEqualTo(0); assertThat(sum(counter, PacketStatusResult.FAILED.name())).isEqualTo(i + 1); } } |
PrometheusMetricsService implements MetricsService { @Override public void trackNumRateLimitedPackets(final AccountSettings accountSettings) { Objects.requireNonNull(accountSettings); PrometheusCollectors.rateLimitedPackets.labels( accountSettings.accountId().value(), accountSettings.assetCode(), stringify(accountSettings.assetScale()) ).inc(); } @Override void trackIncomingPacketPrepared(AccountSettings accountSettings, InterledgerPreparePacket preparePacket); @Override void trackIncomingPacketFulfilled(
final AccountSettings accountSettings, final InterledgerFulfillPacket fulfillPacket
); @Override void trackIncomingPacketRejected(
final AccountSettings accountSettings, final InterledgerRejectPacket rejectPacket
); @Override void trackIncomingPacketFailed(final AccountSettings accountSettings); @Override void trackOutgoingPacketPrepared(AccountSettings accountSettings, InterledgerPreparePacket preparePacket); @Override void trackOutgoingPacketFulfilled(
final AccountSettings accountSettings, final InterledgerFulfillPacket fulfillPacket
); @Override void trackOutgoingPacketRejected(
final AccountSettings accountSettings, final InterledgerRejectPacket rejectPacket
); @Override void trackOutgoingPacketFailed(final AccountSettings accountSettings); @Override void trackNumRateLimitedPackets(final AccountSettings accountSettings); @Override void trackIncomingSettlementSucceeded(IncomingSettlementSucceededEvent event); @Override void trackIncomingSettlementFailed(IncomingSettlementFailedEvent event); @Override void trackOutgoingSettlementInitiationSucceeded(final OutgoingSettlementInitiationSucceededEvent event); @Override void trackOutgoingSettlementInitiationFailed(OutgoingSettlementInitiationFailedEvent event); } | @Test public void trackNumRateLimitedPackets() { final Counter counter = PrometheusCollectors.rateLimitedPackets; assertThat(sum(counter)).isEqualTo(0); for (int i = 0; i < 100; i++) { metricsService.trackNumRateLimitedPackets(accountSettings()); assertThat(sum(counter)).isEqualTo(i + 1); } } |
PrometheusMetricsService implements MetricsService { @Override public void trackIncomingSettlementSucceeded(IncomingSettlementSucceededEvent event) { Objects.requireNonNull(event); event.accountSettings().ifPresent(accountSettings -> PrometheusCollectors.incomingSettlements.labels( SETTLEMENT_SUCCEEDED, accountSettings.accountId().value(), accountSettings.assetCode(), accountSettings.assetScale() + "" ).inc() ); } @Override void trackIncomingPacketPrepared(AccountSettings accountSettings, InterledgerPreparePacket preparePacket); @Override void trackIncomingPacketFulfilled(
final AccountSettings accountSettings, final InterledgerFulfillPacket fulfillPacket
); @Override void trackIncomingPacketRejected(
final AccountSettings accountSettings, final InterledgerRejectPacket rejectPacket
); @Override void trackIncomingPacketFailed(final AccountSettings accountSettings); @Override void trackOutgoingPacketPrepared(AccountSettings accountSettings, InterledgerPreparePacket preparePacket); @Override void trackOutgoingPacketFulfilled(
final AccountSettings accountSettings, final InterledgerFulfillPacket fulfillPacket
); @Override void trackOutgoingPacketRejected(
final AccountSettings accountSettings, final InterledgerRejectPacket rejectPacket
); @Override void trackOutgoingPacketFailed(final AccountSettings accountSettings); @Override void trackNumRateLimitedPackets(final AccountSettings accountSettings); @Override void trackIncomingSettlementSucceeded(IncomingSettlementSucceededEvent event); @Override void trackIncomingSettlementFailed(IncomingSettlementFailedEvent event); @Override void trackOutgoingSettlementInitiationSucceeded(final OutgoingSettlementInitiationSucceededEvent event); @Override void trackOutgoingSettlementInitiationFailed(OutgoingSettlementInitiationFailedEvent event); } | @Test public void trackIncomingSettlementSucceeded() { final Counter counter = PrometheusCollectors.incomingSettlements; assertThat(sum(counter)).isEqualTo(0); for (int i = 0; i < 100; i++) { metricsService.trackIncomingSettlementSucceeded(incomingSettlementSucceededEvent()); assertThat(sum(counter)).isEqualTo(i + 1); assertThat(sum(counter, SETTLEMENT_SUCCEEDED)).isEqualTo(i + 1); assertThat(sum(counter, SETTLEMENT_FAILED)).isEqualTo(0); } metricsService.trackIncomingSettlementFailed(incomingSettlementFailedEvent()); assertThat(sum(counter)).isEqualTo(101); assertThat(sum(counter, SETTLEMENT_SUCCEEDED)).isEqualTo(100); assertThat(sum(counter, SETTLEMENT_FAILED)).isEqualTo(1); } |
PrometheusMetricsService implements MetricsService { @Override public void trackIncomingSettlementFailed(IncomingSettlementFailedEvent event) { Objects.requireNonNull(event); PrometheusCollectors.incomingSettlements.labels( SETTLEMENT_FAILED, event.requestedAccountId().value(), event.accountSettings().map(AccountSettings::assetCode).orElse(null), event.accountSettings().map(as -> as.assetScale() + "").orElse(null) ).inc(); } @Override void trackIncomingPacketPrepared(AccountSettings accountSettings, InterledgerPreparePacket preparePacket); @Override void trackIncomingPacketFulfilled(
final AccountSettings accountSettings, final InterledgerFulfillPacket fulfillPacket
); @Override void trackIncomingPacketRejected(
final AccountSettings accountSettings, final InterledgerRejectPacket rejectPacket
); @Override void trackIncomingPacketFailed(final AccountSettings accountSettings); @Override void trackOutgoingPacketPrepared(AccountSettings accountSettings, InterledgerPreparePacket preparePacket); @Override void trackOutgoingPacketFulfilled(
final AccountSettings accountSettings, final InterledgerFulfillPacket fulfillPacket
); @Override void trackOutgoingPacketRejected(
final AccountSettings accountSettings, final InterledgerRejectPacket rejectPacket
); @Override void trackOutgoingPacketFailed(final AccountSettings accountSettings); @Override void trackNumRateLimitedPackets(final AccountSettings accountSettings); @Override void trackIncomingSettlementSucceeded(IncomingSettlementSucceededEvent event); @Override void trackIncomingSettlementFailed(IncomingSettlementFailedEvent event); @Override void trackOutgoingSettlementInitiationSucceeded(final OutgoingSettlementInitiationSucceededEvent event); @Override void trackOutgoingSettlementInitiationFailed(OutgoingSettlementInitiationFailedEvent event); } | @Test public void trackIncomingSettlementFailed() { final Counter counter = PrometheusCollectors.incomingSettlements; assertThat(sum(counter)).isEqualTo(0); for (int i = 0; i < 100; i++) { metricsService.trackIncomingSettlementFailed(incomingSettlementFailedEvent()); assertThat(sum(counter)).isEqualTo(i + 1); assertThat(sum(counter, SETTLEMENT_SUCCEEDED)).isEqualTo(0); assertThat(sum(counter, SETTLEMENT_FAILED)).isEqualTo(i + 1); } metricsService.trackIncomingSettlementSucceeded(incomingSettlementSucceededEvent()); assertThat(sum(counter)).isEqualTo(101); assertThat(sum(counter, SETTLEMENT_SUCCEEDED)).isEqualTo(1); assertThat(sum(counter, SETTLEMENT_FAILED)).isEqualTo(100); } |
PrometheusMetricsService implements MetricsService { @Override public void trackOutgoingSettlementInitiationSucceeded(final OutgoingSettlementInitiationSucceededEvent event) { Objects.requireNonNull(event); event.accountSettings().ifPresent(accountSettings -> PrometheusCollectors.outgoingSettlements.labels( SETTLEMENT_SUCCEEDED, accountSettings.accountId().value(), accountSettings.assetCode(), accountSettings.assetScale() + "" ).inc() ); } @Override void trackIncomingPacketPrepared(AccountSettings accountSettings, InterledgerPreparePacket preparePacket); @Override void trackIncomingPacketFulfilled(
final AccountSettings accountSettings, final InterledgerFulfillPacket fulfillPacket
); @Override void trackIncomingPacketRejected(
final AccountSettings accountSettings, final InterledgerRejectPacket rejectPacket
); @Override void trackIncomingPacketFailed(final AccountSettings accountSettings); @Override void trackOutgoingPacketPrepared(AccountSettings accountSettings, InterledgerPreparePacket preparePacket); @Override void trackOutgoingPacketFulfilled(
final AccountSettings accountSettings, final InterledgerFulfillPacket fulfillPacket
); @Override void trackOutgoingPacketRejected(
final AccountSettings accountSettings, final InterledgerRejectPacket rejectPacket
); @Override void trackOutgoingPacketFailed(final AccountSettings accountSettings); @Override void trackNumRateLimitedPackets(final AccountSettings accountSettings); @Override void trackIncomingSettlementSucceeded(IncomingSettlementSucceededEvent event); @Override void trackIncomingSettlementFailed(IncomingSettlementFailedEvent event); @Override void trackOutgoingSettlementInitiationSucceeded(final OutgoingSettlementInitiationSucceededEvent event); @Override void trackOutgoingSettlementInitiationFailed(OutgoingSettlementInitiationFailedEvent event); } | @Test public void trackOutgoingSettlementInitiationSucceeded() { final Counter counter = PrometheusCollectors.outgoingSettlements; assertThat(sum(counter)).isEqualTo(0); for (int i = 0; i < 100; i++) { metricsService.trackOutgoingSettlementInitiationSucceeded(outgoingSettlementInitiationSucceededEvent()); assertThat(sum(counter)).isEqualTo(i + 1); assertThat(sum(counter, SETTLEMENT_SUCCEEDED)).isEqualTo(i + 1); assertThat(sum(counter, SETTLEMENT_FAILED)).isEqualTo(0); } metricsService.trackOutgoingSettlementInitiationFailed(outgoingSettlementInitiationFailedEvent()); assertThat(sum(counter)).isEqualTo(101); assertThat(sum(counter, SETTLEMENT_SUCCEEDED)).isEqualTo(100); assertThat(sum(counter, SETTLEMENT_FAILED)).isEqualTo(1); } |
SpspController { @VisibleForTesting protected final String computePaymentTargetIntermediatePrefix(final String requestUrlPath) { Objects.requireNonNull(requestUrlPath); String paymentTarget = this.spspUrlPath .map(spspUrlPath -> { if (!StringUtils.startsWith(requestUrlPath, spspUrlPath)) { return ""; } else { String returnable = StringUtils.trimToEmpty(requestUrlPath).replace(spspUrlPath, ""); if (returnable.endsWith("/")) { returnable = returnable.substring(0, returnable.length() - 1); } return returnable; } }) .orElse(StringUtils.trimToEmpty(requestUrlPath)); paymentTarget = paymentTarget.replace("/", "."); paymentTarget = paymentTarget.replace("..", "."); if (StringUtils.startsWith(paymentTarget, ".")) { paymentTarget = paymentTarget.replaceFirst(".", ""); } if (StringUtils.endsWith(paymentTarget, ".")) { paymentTarget = paymentTarget.substring(0, paymentTarget.length() - 1); } return paymentTarget; } SpspController(
final Supplier<ConnectorSettings> connectorSettingsSupplier,
final StreamReceiver streamReceiver,
@Value("${" + SPSP__URL_PATH + ":}") final String spspUrlPath
); @RequestMapping( path = "/**", method = RequestMethod.GET, produces = {APPLICATION_SPSP4_JSON_VALUE, APPLICATION_JSON_VALUE, MediaTypes.PROBLEM_VALUE} ) ResponseEntity<StreamConnectionDetails> getSpspResponse(final HttpServletRequest httpServletRequest); } | @Test public void computePaymentTargetIntermediatePrefixWithNull() { expectedException.expect(NullPointerException.class); spspController.computePaymentTargetIntermediatePrefix(null); }
@Test public void computePaymentTargetIntermediatePrefix() { spspController = new SpspController(() -> connectorSettingsMock, streamReceiverMock, "/spsp"); assertThat(spspController.computePaymentTargetIntermediatePrefix("")).isEqualTo(""); assertThat(spspController.computePaymentTargetIntermediatePrefix(" ")).isEqualTo(""); assertThat(spspController.computePaymentTargetIntermediatePrefix("/")).isEqualTo(""); assertThat(spspController.computePaymentTargetIntermediatePrefix(" assertThat(spspController.computePaymentTargetIntermediatePrefix("/ ")).isEqualTo(""); assertThat(spspController.computePaymentTargetIntermediatePrefix("/foo")).isEqualTo(""); assertThat(spspController.computePaymentTargetIntermediatePrefix("/foo/")).isEqualTo(""); assertThat(spspController.computePaymentTargetIntermediatePrefix("/foo.bar")).isEqualTo(""); assertThat(spspController.computePaymentTargetIntermediatePrefix("/foo.bar/")).isEqualTo(""); assertThat(spspController.computePaymentTargetIntermediatePrefix("/foo/bar")).isEqualTo(""); assertThat(spspController.computePaymentTargetIntermediatePrefix("/foo.bar/baz")).isEqualTo(""); assertThat(spspController.computePaymentTargetIntermediatePrefix("/foo.bar/baz/")).isEqualTo(""); assertThat(spspController.computePaymentTargetIntermediatePrefix("/spsp")).isEqualTo(""); assertThat(spspController.computePaymentTargetIntermediatePrefix("/spsp/")).isEqualTo(""); assertThat(spspController.computePaymentTargetIntermediatePrefix("/spsp assertThat(spspController.computePaymentTargetIntermediatePrefix("/spsp/foo")).isEqualTo("foo"); assertThat(spspController.computePaymentTargetIntermediatePrefix("/spsp/foo/")).isEqualTo("foo"); assertThat(spspController.computePaymentTargetIntermediatePrefix("/spsp/foo assertThat(spspController.computePaymentTargetIntermediatePrefix("/spsp/foo.bar")).isEqualTo("foo.bar"); assertThat(spspController.computePaymentTargetIntermediatePrefix("/spsp/foo.bar/")).isEqualTo("foo.bar"); assertThat(spspController.computePaymentTargetIntermediatePrefix("/spsp/foo/bar")).isEqualTo("foo.bar"); assertThat(spspController.computePaymentTargetIntermediatePrefix("/spsp/foo.bar/baz")).isEqualTo("foo.bar.baz"); assertThat(spspController.computePaymentTargetIntermediatePrefix("/spsp/foo.bar/baz/")).isEqualTo("foo.bar.baz"); }
@Test public void computePaymentTargetIntermediatePrefixWithOtherPath() { spspController = new SpspController(() -> connectorSettingsMock, streamReceiverMock, "/p"); assertThat(spspController.computePaymentTargetIntermediatePrefix("")).isEqualTo(""); assertThat(spspController.computePaymentTargetIntermediatePrefix(" ")).isEqualTo(""); assertThat(spspController.computePaymentTargetIntermediatePrefix("/")).isEqualTo(""); assertThat(spspController.computePaymentTargetIntermediatePrefix(" assertThat(spspController.computePaymentTargetIntermediatePrefix("/ ")).isEqualTo(""); assertThat(spspController.computePaymentTargetIntermediatePrefix("/foo")).isEqualTo(""); assertThat(spspController.computePaymentTargetIntermediatePrefix("/foo/")).isEqualTo(""); assertThat(spspController.computePaymentTargetIntermediatePrefix("/foo.bar")).isEqualTo(""); assertThat(spspController.computePaymentTargetIntermediatePrefix("/foo.bar/")).isEqualTo(""); assertThat(spspController.computePaymentTargetIntermediatePrefix("/foo/bar")).isEqualTo(""); assertThat(spspController.computePaymentTargetIntermediatePrefix("/foo.bar/baz")).isEqualTo(""); assertThat(spspController.computePaymentTargetIntermediatePrefix("/foo.bar/baz/")).isEqualTo(""); assertThat(spspController.computePaymentTargetIntermediatePrefix("/p")).isEqualTo(""); assertThat(spspController.computePaymentTargetIntermediatePrefix("/p/")).isEqualTo(""); assertThat(spspController.computePaymentTargetIntermediatePrefix("/p assertThat(spspController.computePaymentTargetIntermediatePrefix("/p/foo")).isEqualTo("foo"); assertThat(spspController.computePaymentTargetIntermediatePrefix("/p/foo/")).isEqualTo("foo"); assertThat(spspController.computePaymentTargetIntermediatePrefix("/p/foo assertThat(spspController.computePaymentTargetIntermediatePrefix("/p/foo.bar")).isEqualTo("foo.bar"); assertThat(spspController.computePaymentTargetIntermediatePrefix("/p/foo.bar/")).isEqualTo("foo.bar"); assertThat(spspController.computePaymentTargetIntermediatePrefix("/p/foo/bar")).isEqualTo("foo.bar"); assertThat(spspController.computePaymentTargetIntermediatePrefix("/p/foo.bar/baz")).isEqualTo("foo.bar.baz"); assertThat(spspController.computePaymentTargetIntermediatePrefix("/p/foo.bar/baz/")).isEqualTo("foo.bar.baz"); }
@Test public void computePaymentTargetIntermediatePrefixWithEmptySpspPath() { spspController = new SpspController(() -> connectorSettingsMock, streamReceiverMock, ""); assertThat(spspController.computePaymentTargetIntermediatePrefix("")).isEqualTo(""); assertThat(spspController.computePaymentTargetIntermediatePrefix(" ")).isEqualTo(""); assertThat(spspController.computePaymentTargetIntermediatePrefix("/")).isEqualTo(""); assertThat(spspController.computePaymentTargetIntermediatePrefix(" assertThat(spspController.computePaymentTargetIntermediatePrefix("/ ")).isEqualTo(""); assertThat(spspController.computePaymentTargetIntermediatePrefix("/foo")).isEqualTo("foo"); assertThat(spspController.computePaymentTargetIntermediatePrefix("/foo/")).isEqualTo("foo"); assertThat(spspController.computePaymentTargetIntermediatePrefix("/foo.bar")).isEqualTo("foo.bar"); assertThat(spspController.computePaymentTargetIntermediatePrefix("/foo.bar/")).isEqualTo("foo.bar"); assertThat(spspController.computePaymentTargetIntermediatePrefix("/foo/bar")).isEqualTo("foo.bar"); assertThat(spspController.computePaymentTargetIntermediatePrefix("/foo.bar/baz")).isEqualTo("foo.bar.baz"); assertThat(spspController.computePaymentTargetIntermediatePrefix("/foo.bar/baz/")).isEqualTo("foo.bar.baz"); assertThat(spspController.computePaymentTargetIntermediatePrefix("/p")).isEqualTo("p"); assertThat(spspController.computePaymentTargetIntermediatePrefix("/p/")).isEqualTo("p"); assertThat(spspController.computePaymentTargetIntermediatePrefix("/p assertThat(spspController.computePaymentTargetIntermediatePrefix("/p/foo")).isEqualTo("p.foo"); assertThat(spspController.computePaymentTargetIntermediatePrefix("/p/foo/")).isEqualTo("p.foo"); assertThat(spspController.computePaymentTargetIntermediatePrefix("/p/foo assertThat(spspController.computePaymentTargetIntermediatePrefix("/p/foo.bar")).isEqualTo("p.foo.bar"); assertThat(spspController.computePaymentTargetIntermediatePrefix("/p/foo.bar/")).isEqualTo("p.foo.bar"); assertThat(spspController.computePaymentTargetIntermediatePrefix("/p/foo/bar")).isEqualTo("p.foo.bar"); assertThat(spspController.computePaymentTargetIntermediatePrefix("/p/foo.bar/baz")).isEqualTo("p.foo.bar.baz"); assertThat(spspController.computePaymentTargetIntermediatePrefix("/p/foo.bar/baz/")).isEqualTo("p.foo.bar.baz"); } |
PrometheusMetricsService implements MetricsService { @Override public void trackOutgoingSettlementInitiationFailed(OutgoingSettlementInitiationFailedEvent event) { Objects.requireNonNull(event); event.accountSettings().ifPresent(accountSettings -> PrometheusCollectors.outgoingSettlements.labels( SETTLEMENT_FAILED, accountSettings.accountId().value(), accountSettings.assetCode(), accountSettings.assetScale() + "" ).inc() ); } @Override void trackIncomingPacketPrepared(AccountSettings accountSettings, InterledgerPreparePacket preparePacket); @Override void trackIncomingPacketFulfilled(
final AccountSettings accountSettings, final InterledgerFulfillPacket fulfillPacket
); @Override void trackIncomingPacketRejected(
final AccountSettings accountSettings, final InterledgerRejectPacket rejectPacket
); @Override void trackIncomingPacketFailed(final AccountSettings accountSettings); @Override void trackOutgoingPacketPrepared(AccountSettings accountSettings, InterledgerPreparePacket preparePacket); @Override void trackOutgoingPacketFulfilled(
final AccountSettings accountSettings, final InterledgerFulfillPacket fulfillPacket
); @Override void trackOutgoingPacketRejected(
final AccountSettings accountSettings, final InterledgerRejectPacket rejectPacket
); @Override void trackOutgoingPacketFailed(final AccountSettings accountSettings); @Override void trackNumRateLimitedPackets(final AccountSettings accountSettings); @Override void trackIncomingSettlementSucceeded(IncomingSettlementSucceededEvent event); @Override void trackIncomingSettlementFailed(IncomingSettlementFailedEvent event); @Override void trackOutgoingSettlementInitiationSucceeded(final OutgoingSettlementInitiationSucceededEvent event); @Override void trackOutgoingSettlementInitiationFailed(OutgoingSettlementInitiationFailedEvent event); } | @Test public void trackOutgoingSettlementInitiationFailed() { final Counter counter = PrometheusCollectors.outgoingSettlements; assertThat(sum(counter)).isEqualTo(0); for (int i = 0; i < 100; i++) { metricsService.trackOutgoingSettlementInitiationFailed(outgoingSettlementInitiationFailedEvent()); assertThat(sum(counter)).isEqualTo(i + 1); assertThat(sum(counter, SETTLEMENT_SUCCEEDED)).isEqualTo(0); assertThat(sum(counter, SETTLEMENT_FAILED)).isEqualTo(i + 1); } metricsService.trackOutgoingSettlementInitiationSucceeded(outgoingSettlementInitiationSucceededEvent()); assertThat(sum(counter)).isEqualTo(101); assertThat(sum(counter, SETTLEMENT_SUCCEEDED)).isEqualTo(1); assertThat(sum(counter, SETTLEMENT_FAILED)).isEqualTo(100); } |
JavaMoneyUtils { public MonetaryAmount toMonetaryAmount( final CurrencyUnit currencyUnit, final BigInteger assetAmount, final int assetScale ) { final BigDecimal scaledAmount = BigDecimal.valueOf(assetAmount.longValue(), assetScale); return Money.of(scaledAmount, currencyUnit); } MonetaryAmount toMonetaryAmount(
final CurrencyUnit currencyUnit, final BigInteger assetAmount, final int assetScale
); BigInteger toInterledgerAmount(MonetaryAmount monetaryAmount, int assetScale); } | @Test public void toMonetaryAmountInvalidUnits() { final CurrencyUnit currencyUSD = Monetary.getCurrency("USD"); final int assetScale = 2; BigDecimal cents = BigDecimal.valueOf(0.1); assertThat( javaMoneyUtils.toMonetaryAmount(currencyUSD, cents.toBigInteger(), assetScale).getNumber().intValueExact()) .isEqualTo(0); }
@Test public void toMonetaryAmountUSDToUSD() { final CurrencyUnit currencyUSD = Monetary.getCurrency("USD"); final int assetScale = 0; BigInteger cents = BigInteger.ZERO; assertThat(javaMoneyUtils.toMonetaryAmount(currencyUSD, cents, assetScale) .getNumber().numberValue(BigDecimal.class)).isEqualTo(new BigDecimal("0")); cents = BigInteger.ONE; assertThat(javaMoneyUtils.toMonetaryAmount(currencyUSD, cents, assetScale) .getNumber().numberValue(BigDecimal.class)).isEqualTo(new BigDecimal("1")); cents = BigInteger.valueOf(100); assertThat(javaMoneyUtils.toMonetaryAmount(currencyUSD, cents, assetScale) .getNumber().numberValue(BigDecimal.class)).isEqualTo(new BigDecimal("100")); cents = BigInteger.valueOf(199); assertThat(javaMoneyUtils.toMonetaryAmount(currencyUSD, cents, assetScale) .getNumber().numberValue(BigDecimal.class)).isEqualTo(new BigDecimal("199")); cents = BigInteger.valueOf(1999); assertThat(javaMoneyUtils.toMonetaryAmount(currencyUSD, cents, assetScale) .getNumber().numberValue(BigDecimal.class)).isEqualTo(new BigDecimal("1999")); }
@Test public void toMonetaryAmountCentsToUSD() { final CurrencyUnit currencyUSD = Monetary.getCurrency("USD"); final int assetScale = 2; BigInteger cents = BigInteger.ZERO; assertThat(javaMoneyUtils.toMonetaryAmount(currencyUSD, cents, assetScale) .getNumber().numberValue(BigDecimal.class)).isEqualTo(new BigDecimal("0")); cents = BigInteger.ONE; assertThat(javaMoneyUtils.toMonetaryAmount(currencyUSD, cents, assetScale) .getNumber().numberValue(BigDecimal.class)).isEqualTo(new BigDecimal("0.01")); cents = BigInteger.valueOf(100); assertThat(javaMoneyUtils.toMonetaryAmount(currencyUSD, cents, assetScale) .getNumber().numberValue(BigDecimal.class)).isEqualTo(new BigDecimal("1")); cents = BigInteger.valueOf(199); assertThat(javaMoneyUtils.toMonetaryAmount(currencyUSD, cents, assetScale) .getNumber().numberValue(BigDecimal.class)).isEqualTo(new BigDecimal("1.99")); cents = BigInteger.valueOf(1999); assertThat(javaMoneyUtils.toMonetaryAmount(currencyUSD, cents, assetScale) .getNumber().numberValue(BigDecimal.class)).isEqualTo(new BigDecimal("19.99")); }
@Test public void toMonetaryAmountNanoDollarsToUSD() { final CurrencyUnit currencyUSD = Monetary.getCurrency("USD"); final int assetScale = 9; BigInteger cents = BigInteger.ZERO; assertThat(javaMoneyUtils.toMonetaryAmount(currencyUSD, cents, assetScale) .getNumber().numberValue(BigDecimal.class)).isEqualTo(new BigDecimal("0")); cents = BigInteger.ONE; assertThat(javaMoneyUtils.toMonetaryAmount(currencyUSD, cents, assetScale) .getNumber().numberValue(BigDecimal.class)).isEqualTo(new BigDecimal("0.000000001")); cents = BigInteger.valueOf(100); assertThat(javaMoneyUtils.toMonetaryAmount(currencyUSD, cents, assetScale) .getNumber().numberValue(BigDecimal.class)).isEqualTo(new BigDecimal("0.0000001")); cents = BigInteger.valueOf(199); assertThat(javaMoneyUtils.toMonetaryAmount(currencyUSD, cents, assetScale) .getNumber().numberValue(BigDecimal.class)).isEqualTo(new BigDecimal("0.000000199")); cents = BigInteger.valueOf(1999); assertThat(javaMoneyUtils.toMonetaryAmount(currencyUSD, cents, assetScale) .getNumber().numberValue(BigDecimal.class)).isEqualTo(new BigDecimal("0.000001999")); }
@Test public void toMonetaryAmountDropsToXRP() { final CurrencyUnit currencyXRP = Monetary.getCurrency("XRP"); final int assetScale = 6; BigInteger cents = BigInteger.ZERO; assertThat(javaMoneyUtils.toMonetaryAmount(currencyXRP, cents, assetScale) .getNumber().numberValue(BigDecimal.class)).isEqualTo(new BigDecimal("0")); cents = BigInteger.ONE; assertThat(javaMoneyUtils.toMonetaryAmount(currencyXRP, cents, assetScale) .getNumber().numberValue(BigDecimal.class)).isEqualTo(new BigDecimal("0.000001")); cents = BigInteger.valueOf(100); assertThat(javaMoneyUtils.toMonetaryAmount(currencyXRP, cents, assetScale) .getNumber().numberValue(BigDecimal.class)).isEqualTo(new BigDecimal("0.0001")); cents = BigInteger.valueOf(199); assertThat(javaMoneyUtils.toMonetaryAmount(currencyXRP, cents, assetScale) .getNumber().numberValue(BigDecimal.class)).isEqualTo(new BigDecimal("0.000199")); cents = BigInteger.valueOf(1999); assertThat(javaMoneyUtils.toMonetaryAmount(currencyXRP, cents, assetScale) .getNumber().numberValue(BigDecimal.class)).isEqualTo(new BigDecimal("0.001999")); }
@Test public void toMonetaryAmountDropsToDrops() { final CurrencyUnit currencyXRP = Monetary.getCurrency("XRP"); final int assetScale = 9; BigInteger drops = BigInteger.ZERO; assertThat(javaMoneyUtils.toMonetaryAmount(currencyXRP, drops, assetScale) .getNumber().numberValue(BigDecimal.class)).isEqualTo(new BigDecimal("0")); drops = BigInteger.ONE; assertThat(javaMoneyUtils.toMonetaryAmount(currencyXRP, drops, assetScale) .getNumber().numberValue(BigDecimal.class)).isEqualTo(new BigDecimal("0.000000001")); drops = BigInteger.valueOf(100); assertThat(javaMoneyUtils.toMonetaryAmount(currencyXRP, drops, assetScale) .getNumber().numberValue(BigDecimal.class)).isEqualTo(new BigDecimal("0.0000001")); drops = BigInteger.valueOf(199); assertThat(javaMoneyUtils.toMonetaryAmount(currencyXRP, drops, assetScale) .getNumber().numberValue(BigDecimal.class)).isEqualTo(new BigDecimal("0.000000199")); drops = BigInteger.valueOf(1999); assertThat(javaMoneyUtils.toMonetaryAmount(currencyXRP, drops, assetScale) .getNumber().numberValue(BigDecimal.class)).isEqualTo(new BigDecimal("0.000001999")); drops = BigInteger.valueOf(1000000000L); assertThat(javaMoneyUtils.toMonetaryAmount(currencyXRP, drops, assetScale) .getNumber().numberValue(BigDecimal.class)).isEqualTo(new BigDecimal("1")); }
@Test public void toMonetaryAmountXRPToXRP() { final CurrencyUnit currencyXRP = Monetary.getCurrency("XRP"); final int assetScale = 0; BigInteger cents = BigInteger.ZERO; assertThat(javaMoneyUtils.toMonetaryAmount(currencyXRP, cents, assetScale) .getNumber().numberValue(BigDecimal.class)).isEqualTo(new BigDecimal("0")); cents = BigInteger.ONE; assertThat(javaMoneyUtils.toMonetaryAmount(currencyXRP, cents, assetScale) .getNumber().numberValue(BigDecimal.class)).isEqualTo(new BigDecimal("1")); cents = BigInteger.valueOf(100); assertThat(javaMoneyUtils.toMonetaryAmount(currencyXRP, cents, assetScale) .getNumber().numberValue(BigDecimal.class)).isEqualTo(new BigDecimal("100")); cents = BigInteger.valueOf(199); assertThat(javaMoneyUtils.toMonetaryAmount(currencyXRP, cents, assetScale) .getNumber().numberValue(BigDecimal.class)).isEqualTo(new BigDecimal("199")); cents = BigInteger.valueOf(1999); assertThat(javaMoneyUtils.toMonetaryAmount(currencyXRP, cents, assetScale) .getNumber().numberValue(BigDecimal.class)).isEqualTo(new BigDecimal("1999")); } |
JavaMoneyUtils { public BigInteger toInterledgerAmount(MonetaryAmount monetaryAmount, int assetScale) { return monetaryAmount.scaleByPowerOfTen(assetScale).getNumber().numberValue(BigDecimal.class) .toBigInteger(); } MonetaryAmount toMonetaryAmount(
final CurrencyUnit currencyUnit, final BigInteger assetAmount, final int assetScale
); BigInteger toInterledgerAmount(MonetaryAmount monetaryAmount, int assetScale); } | @Test public void toInterledgerAmountUSDToUSD() { final CurrencyUnit currencyUSD = Monetary.getCurrency("USD"); final int assetScale = 0; Money money = Money.of(BigInteger.ZERO, currencyUSD); assertThat(javaMoneyUtils.toInterledgerAmount(money, assetScale)).isEqualTo(BigInteger.ZERO); money = Money.of(BigInteger.ONE, currencyUSD); assertThat(javaMoneyUtils.toInterledgerAmount(money, assetScale)).isEqualTo(BigInteger.ONE); money = Money.of(BigInteger.valueOf(100), currencyUSD); assertThat(javaMoneyUtils.toInterledgerAmount(money, assetScale)).isEqualTo(BigInteger.valueOf(100L)); money = Money.of(BigInteger.valueOf(199), currencyUSD); assertThat(javaMoneyUtils.toInterledgerAmount(money, assetScale)).isEqualTo(BigInteger.valueOf(199L)); money = Money.of(BigInteger.valueOf(1999), currencyUSD); assertThat(javaMoneyUtils.toInterledgerAmount(money, assetScale)).isEqualTo(BigInteger.valueOf(1999L)); money = Money.of(BigInteger.valueOf(600000000), currencyUSD); assertThat(javaMoneyUtils.toInterledgerAmount(money, assetScale)).isEqualTo(BigInteger.valueOf(600000000L)); }
@Test public void toInterledgerAmountDropsToDrops() { final CurrencyUnit currencyXRP = Monetary.getCurrency("XRP"); final int assetScale = 9; Money money = Money.of(BigInteger.ZERO, currencyXRP); assertThat(javaMoneyUtils.toInterledgerAmount(money, assetScale)).isEqualTo(BigInteger.ZERO); money = Money.of(BigInteger.valueOf(1), currencyXRP); assertThat(javaMoneyUtils.toInterledgerAmount(money, assetScale)).isEqualTo(BigInteger.valueOf(1000000000L)); money = Money.of(BigDecimal.valueOf(0.1), currencyXRP); assertThat(javaMoneyUtils.toInterledgerAmount(money, assetScale)).isEqualTo(BigInteger.valueOf(100000000L)); money = Money.of(BigDecimal.valueOf(0.01), currencyXRP); assertThat(javaMoneyUtils.toInterledgerAmount(money, assetScale)).isEqualTo(BigInteger.valueOf(10000000L)); money = Money.of(BigDecimal.valueOf(0.001), currencyXRP); assertThat(javaMoneyUtils.toInterledgerAmount(money, assetScale)).isEqualTo(BigInteger.valueOf(1000000L)); money = Money.of(BigDecimal.valueOf(0.000001), currencyXRP); assertThat(javaMoneyUtils.toInterledgerAmount(money, assetScale)).isEqualTo(BigInteger.valueOf(1000L)); money = Money.of(BigDecimal.valueOf(0.000000001), currencyXRP); assertThat(javaMoneyUtils.toInterledgerAmount(money, assetScale)).isEqualTo(BigInteger.valueOf(1L)); money = Money.of(BigDecimal.valueOf(0.000000000001), currencyXRP); assertThat(javaMoneyUtils.toInterledgerAmount(money, assetScale)).isEqualTo(BigInteger.valueOf(0)); }
@Test public void toInterledgerAmountCentsToUSD() { final CurrencyUnit currencyUSD = Monetary.getCurrency("USD"); final int assetScale = 2; Money money = Money.of(new BigDecimal("0.0"), currencyUSD); assertThat(javaMoneyUtils.toInterledgerAmount(money, assetScale)).isEqualTo(BigInteger.ZERO); money = Money.of(new BigDecimal("0.00000027214"), currencyUSD); assertThat(javaMoneyUtils.toInterledgerAmount(money, assetScale)).isEqualTo(BigInteger.ZERO); money = Money.of(new BigDecimal("0.001"), currencyUSD); assertThat(javaMoneyUtils.toInterledgerAmount(money, assetScale)).isEqualTo(BigInteger.ZERO); money = Money.of(new BigDecimal("0.009"), currencyUSD); assertThat(javaMoneyUtils.toInterledgerAmount(money, assetScale)).isEqualTo(BigInteger.ZERO); money = Money.of(new BigDecimal("0.01"), currencyUSD); assertThat(javaMoneyUtils.toInterledgerAmount(money, assetScale)).isEqualTo(BigInteger.ONE); money = Money.of(new BigDecimal("1.00"), currencyUSD); assertThat(javaMoneyUtils.toInterledgerAmount(money, assetScale)).isEqualTo(BigInteger.valueOf(100L)); money = Money.of(new BigDecimal("1.99"), currencyUSD); assertThat(javaMoneyUtils.toInterledgerAmount(money, assetScale)).isEqualTo(BigInteger.valueOf(199L)); money = Money.of(new BigDecimal("19.99"), currencyUSD); assertThat(javaMoneyUtils.toInterledgerAmount(money, assetScale)).isEqualTo(BigInteger.valueOf(1999L)); money = Money.of(new BigDecimal("6000000"), currencyUSD); assertThat(javaMoneyUtils.toInterledgerAmount(money, assetScale)).isEqualTo(BigInteger.valueOf(600000000L)); }
@Test public void toInterledgerNanoDollarsToUSD() { final CurrencyUnit currencyUSD = Monetary.getCurrency("USD"); final int assetScale = 9; Money money = Money.of(new BigDecimal("0.000000000"), currencyUSD); assertThat(javaMoneyUtils.toInterledgerAmount(money, assetScale)).isEqualTo(BigInteger.ZERO); money = Money.of(new BigDecimal("0.00000000099"), currencyUSD); assertThat(javaMoneyUtils.toInterledgerAmount(money, assetScale)).isEqualTo(BigInteger.ZERO); money = Money.of(new BigDecimal("0.000000001"), currencyUSD); assertThat(javaMoneyUtils.toInterledgerAmount(money, assetScale)).isEqualTo(BigInteger.ONE); money = Money.of(new BigDecimal("0.0000001"), currencyUSD); assertThat(javaMoneyUtils.toInterledgerAmount(money, assetScale)).isEqualTo(BigInteger.valueOf(100L)); money = Money.of(new BigDecimal("0.000000199"), currencyUSD); assertThat(javaMoneyUtils.toInterledgerAmount(money, assetScale)).isEqualTo(BigInteger.valueOf(199L)); money = Money.of(new BigDecimal("0.000001999"), currencyUSD); assertThat(javaMoneyUtils.toInterledgerAmount(money, assetScale)).isEqualTo(BigInteger.valueOf(1999L)); money = Money.of(new BigDecimal("6000000"), currencyUSD); assertThat(javaMoneyUtils.toInterledgerAmount(money, assetScale)).isEqualTo(BigInteger.valueOf(6000000000000000L)); }
@Test public void toInterledgerAmountDropsToXRP() { final CurrencyUnit currencyUSD = Monetary.getCurrency("XRP"); final int assetScale = 6; Money money = Money.of(new BigDecimal("0.00000000"), currencyUSD); assertThat(javaMoneyUtils.toInterledgerAmount(money, assetScale)).isEqualTo(BigInteger.ZERO); money = Money.of(new BigDecimal("0.000000001"), currencyUSD); assertThat(javaMoneyUtils.toInterledgerAmount(money, assetScale)).isEqualTo(BigInteger.ZERO); money = Money.of(new BigDecimal("0.00000001"), currencyUSD); assertThat(javaMoneyUtils.toInterledgerAmount(money, assetScale)).isEqualTo(BigInteger.ZERO); money = Money.of(new BigDecimal("0.000001"), currencyUSD); assertThat(javaMoneyUtils.toInterledgerAmount(money, assetScale)).isEqualTo(BigInteger.ONE); money = Money.of(new BigDecimal("0.0001"), currencyUSD); assertThat(javaMoneyUtils.toInterledgerAmount(money, assetScale)).isEqualTo(BigInteger.valueOf(100L)); money = Money.of(new BigDecimal("0.000199"), currencyUSD); assertThat(javaMoneyUtils.toInterledgerAmount(money, assetScale)).isEqualTo(BigInteger.valueOf(199L)); money = Money.of(new BigDecimal("0.001999"), currencyUSD); assertThat(javaMoneyUtils.toInterledgerAmount(money, assetScale)).isEqualTo(BigInteger.valueOf(1999L)); money = Money.of(new BigDecimal("6000001"), currencyUSD); assertThat(javaMoneyUtils.toInterledgerAmount(money, assetScale)).isEqualTo(BigInteger.valueOf(6000001000000L)); }
@Test public void toInterledgerAmountXRPToXRP() { final CurrencyUnit currencyUSD = Monetary.getCurrency("XRP"); final int assetScale = 0; Money money = Money.of(BigInteger.ONE, currencyUSD); assertThat(javaMoneyUtils.toInterledgerAmount(money, assetScale)).isEqualTo(BigInteger.ONE); money = Money.of(BigInteger.valueOf(100), currencyUSD); assertThat(javaMoneyUtils.toInterledgerAmount(money, assetScale)).isEqualTo(BigInteger.valueOf(100L)); money = Money.of(BigInteger.valueOf(199), currencyUSD); assertThat(javaMoneyUtils.toInterledgerAmount(money, assetScale)).isEqualTo(BigInteger.valueOf(199L)); money = Money.of(BigInteger.valueOf(1999), currencyUSD); assertThat(javaMoneyUtils.toInterledgerAmount(money, assetScale)).isEqualTo(BigInteger.valueOf(1999L)); money = Money.of(BigInteger.valueOf(600000000), currencyUSD); assertThat(javaMoneyUtils.toInterledgerAmount(money, assetScale)).isEqualTo(BigInteger.valueOf(600000000L)); } |
SpspReceiverEnabledCondition implements Condition { @Override public boolean matches(ConditionContext context, AnnotatedTypeMetadata metadata) { final Environment env = context.getEnvironment(); if (isSpspEnabled(env)) { Preconditions.checkArgument(isLocalSpspFulfillmentEnabled(env), "Local SPSP fulfillment may not be disabled if `%s` is enabled", SPSP_ENABLED ); } if (isLocalSpspFulfillmentEnabled(env)) { return true; } else { return isSpspEnabled(env); } } @Override boolean matches(ConditionContext context, AnnotatedTypeMetadata metadata); } | @Test public void exceptionWhenMissingAndMissing() { when(environmentMock.getProperty(ENABLED_PROTOCOLS + DOT + SPSP_ENABLED)).thenReturn(null); when(environmentMock.getProperty(ENABLED_FEATURES + DOT + LOCAL_SPSP_FULFILLMENT_ENABLED)).thenReturn(null); assertThat(condition.matches(contextMock, metadataMock)).isFalse(); }
@Test public void matchesWhenMissingAndTrue() { when(environmentMock.getProperty(ENABLED_PROTOCOLS + DOT + SPSP_ENABLED)).thenReturn(null); when(environmentMock.getProperty(ENABLED_FEATURES + DOT + LOCAL_SPSP_FULFILLMENT_ENABLED)).thenReturn(TRUE); assertThat(condition.matches(contextMock, metadataMock)).isTrue(); }
@Test public void matchesWhenMissingAndFalse() { when(environmentMock.getProperty(ENABLED_PROTOCOLS + DOT + SPSP_ENABLED)).thenReturn(null); when(environmentMock.getProperty(ENABLED_FEATURES + DOT + LOCAL_SPSP_FULFILLMENT_ENABLED)).thenReturn(FALSE); assertThat(condition.matches(contextMock, metadataMock)).isFalse(); }
@Test public void exceptionWhenTrueAndMissing() { expectedException.expect(IllegalArgumentException.class); expectedException.expectMessage(PRECONDITION_MESSAGE); when(environmentMock.getProperty(ENABLED_PROTOCOLS + DOT + SPSP_ENABLED)).thenReturn(TRUE); when(environmentMock.getProperty(ENABLED_FEATURES + DOT + LOCAL_SPSP_FULFILLMENT_ENABLED)).thenReturn(null); condition.matches(contextMock, metadataMock); }
@Test public void matchesWhenTrueAndFalse() { expectedException.expect(IllegalArgumentException.class); expectedException.expectMessage(PRECONDITION_MESSAGE); when(environmentMock.getProperty(ENABLED_PROTOCOLS + DOT + SPSP_ENABLED)).thenReturn(TRUE); when(environmentMock.getProperty(ENABLED_FEATURES + DOT + LOCAL_SPSP_FULFILLMENT_ENABLED)).thenReturn(FALSE); condition.matches(contextMock, metadataMock); }
@Test public void matchesWhenTrueAndTrue() { when(environmentMock.getProperty(ENABLED_PROTOCOLS + DOT + SPSP_ENABLED)).thenReturn(TRUE); when(environmentMock.getProperty(ENABLED_FEATURES + DOT + LOCAL_SPSP_FULFILLMENT_ENABLED)).thenReturn(TRUE); assertThat(condition.matches(contextMock, metadataMock)).isTrue(); }
@Test public void exceptionWhenFalseAndMissing() { when(environmentMock.getProperty(ENABLED_PROTOCOLS + DOT + SPSP_ENABLED)).thenReturn(FALSE); when(environmentMock.getProperty(ENABLED_FEATURES + DOT + LOCAL_SPSP_FULFILLMENT_ENABLED)).thenReturn(null); assertThat(condition.matches(contextMock, metadataMock)).isFalse(); }
@Test public void exceptionWhenFalseAndFalse() { when(environmentMock.getProperty(ENABLED_PROTOCOLS + DOT + SPSP_ENABLED)).thenReturn(FALSE); when(environmentMock.getProperty(ENABLED_FEATURES + DOT + LOCAL_SPSP_FULFILLMENT_ENABLED)).thenReturn(FALSE); assertThat(condition.matches(contextMock, metadataMock)).isFalse(); }
@Test public void exceptionWhenFalseAndTrue() { when(environmentMock.getProperty(ENABLED_PROTOCOLS + DOT + SPSP_ENABLED)).thenReturn(FALSE); when(environmentMock.getProperty(ENABLED_FEATURES + DOT + LOCAL_SPSP_FULFILLMENT_ENABLED)).thenReturn(TRUE); assertThat(condition.matches(contextMock, metadataMock)).isTrue(); } |
DefaultAccountIdResolver implements BtpAccountIdResolver, IlpOverHttpAccountIdResolver, AccountIdResolver { @Override public AccountId resolveAccountId(final Link<?> link) { Objects.requireNonNull(link); if (link instanceof StatefulLink && !(((StatefulLink<?>) link).isConnected())) { throw new LinkNotConnectedException("Disconnected Plugins do not have an associated account!", link.getLinkId()); } else { return AccountId.of(link.getLinkId().value()); } } @Override AccountId resolveAccountId(final Link<?> link); @Override AccountId resolveAccountId(final BtpSession btpSession); @Override AccountId resolveAccountId(final Authentication authentication); } | @Test public void resolveAccountIdWithNullLink() { expectedException.expect(NullPointerException.class); Link link = null; accountIdResolver.resolveAccountId(link); }
@Test public void resolveAccountIdWithLink() { assertThat(accountIdResolver.resolveAccountId(linkMock)).isEqualTo(AccountId.of(LINK_ID.value())); }
@Test public void resolveAccountIdWithStatefulLinkNotConnected() { when(statefulLinkMock.isConnected()).thenReturn(false); expectedException.expect(LinkNotConnectedException.class); accountIdResolver.resolveAccountId(statefulLinkMock); }
@Test public void resolveAccountIdWithStatefulLinkConnected() { when(statefulLinkMock.isConnected()).thenReturn(true); accountIdResolver.resolveAccountId(statefulLinkMock); assertThat(accountIdResolver.resolveAccountId(statefulLinkMock)).isEqualTo(AccountId.of(LINK_ID.value())); }
@Test public void testResolveAccountWithNullAuthentication() { expectedException.expect(NullPointerException.class); Authentication authentication = null; accountIdResolver.resolveAccountId(authentication); }
@Test public void testResolveAccountWithAuthentication() { Authentication authenticationMock = mock(Authentication.class); when(authenticationMock.getPrincipal()).thenReturn("foo"); assertThat(accountIdResolver.resolveAccountId(authenticationMock)).isEqualTo(AccountId.of("foo")); }
@Test public void testResolveAccountWithNullBtpSession() { expectedException.expect(NullPointerException.class); BtpSession btpSession = null; accountIdResolver.resolveAccountId(btpSession); }
@Test public void testResolveAccountWithBtpSessionWithNoCreds() { expectedException.expect(RuntimeException.class); expectedException.expectMessage("No BtpSessionCredentials found!"); BtpSession btpSessionMock = mock(BtpSession.class); Optional<BtpSessionCredentials> btpSessionCredentials = Optional.empty(); when(btpSessionMock.getBtpSessionCredentials()).thenReturn(btpSessionCredentials); assertThat(accountIdResolver.resolveAccountId(btpSessionMock)); }
@Test public void testResolveAccountWithBtpSessionWithNoAuthUsername() { expectedException.expect(RuntimeException.class); expectedException.expectMessage("Not yet implemented"); BtpSession btpSessionMock = mock(BtpSession.class); Optional<BtpSessionCredentials> btpSessionCredentials = Optional.of(BtpSessionCredentials.builder() .authToken("authToken") .build()); when(btpSessionMock.getBtpSessionCredentials()).thenReturn(btpSessionCredentials); assertThat(accountIdResolver.resolveAccountId(btpSessionMock)).isEqualTo(AccountId.of("foo")); }
@Test public void testResolveAccountWithBtpSession() { BtpSession btpSessionMock = mock(BtpSession.class); Optional<BtpSessionCredentials> btpSessionCredentials = Optional.of(BtpSessionCredentials.builder() .authToken("authToken") .authUsername("authUsername") .build()); when(btpSessionMock.getBtpSessionCredentials()).thenReturn(btpSessionCredentials); assertThat(accountIdResolver.resolveAccountId(btpSessionMock)).isEqualTo(AccountId.of("authUsername")); } |
DefaultAccessTokenManager implements AccessTokenManager { @Override public AccessToken createToken(AccountId accountId) { String newRandomToken = Base64.getEncoder().encodeToString(UUID.randomUUID().toString().getBytes()); AccessTokenEntity newEntity = new AccessTokenEntity(); newEntity.setAccountId(accountId); newEntity.setEncryptedToken(encryptToken(newRandomToken)); AccessTokenEntity saved = accessTokensRepository.save(newEntity); return AccessToken.builder() .from(accessTokensRepository.withConversion(saved)) .rawToken(newRandomToken) .build(); } DefaultAccessTokenManager(PasswordEncoder passwordEncoder,
AccessTokensRepository accessTokensRepository,
EventBus eventBus); @Override AccessToken createToken(AccountId accountId); @Override @Transactional void deleteByAccountIdAndId(AccountId accountId, long id); @Override @Transactional void deleteByAccountId(AccountId accountId); @Override List<AccessToken> findTokensByAccountId(AccountId accountId); @Override Optional<AccessToken> findByAccountIdAndRawToken(AccountId accountId, String rawToken); } | @Test public void createToken() { AccountId accountId = AccountId.of("test"); AccessToken accessToken = manager.createToken(accountId); assertThat(accessToken.rawToken()).isNotEmpty(); assertThat(passwordEncoder.matches(accessToken.rawToken().get(), accessToken.encryptedToken())).isTrue(); } |
DefaultAccountManager implements AccountManager { @VisibleForTesting protected AccountSettingsEntity persistAccountSettingsEntity(AccountSettingsEntity accountSettingsEntity) { AccountSettingsEntity entity; try { entity = this.accountSettingsRepository.save(accountSettingsEntity); } catch (Exception e) { if (e.getCause() instanceof ConstraintViolationException) { ConstraintViolationException cause = (ConstraintViolationException) e.getCause(); if (cause.getConstraintName().contains(DataConstants.ConstraintNames.ACCOUNT_SETTINGS_SETTLEMENT_ENGINE)) { throw new AccountSettlementEngineAlreadyExistsProblem(accountSettingsEntity.getAccountId(), accountSettingsEntity.getSettlementEngineDetailsEntity().getSettlementEngineAccountId()); } } throw e; } return entity; } DefaultAccountManager(
final Supplier<ConnectorSettings> connectorSettingsSupplier,
final ConversionService conversionService,
final AccountSettingsRepository accountSettingsRepository,
final DeletedAccountSettingsRepository deletedAccountSettingsRepository,
final LinkManager linkManager,
final SettlementEngineClient settlementEngineClient,
final LinkSettingsFactory linkSettingsFactory,
final LinkSettingsValidator linkSettingsValidator,
final IldcpFetcherFactory ildcpFetcherFactory,
final EventBus eventBus
); @Override LinkManager getLinkManager(); @Override Optional<AccountSettings> findAccountById(AccountId accountId); @Override List<AccountSettings> getAccounts(); @Override AccountSettings createAccount(final AccountSettings accountSettings); @Override AccountSettings updateAccount(final AccountId accountId, final AccountSettings accountSettings); @Override AccountSettings validateLinkSettings(AccountSettings accountSettings); @Override AccountSettings initializeParentAccountSettingsViaIlDcp(final AccountId accountId); @Override @Transactional void deleteByAccountId(AccountId accountId); } | @Test public void failOnDupeSettlementEngineId() { AccountSettingsEntity entity = mock(AccountSettingsEntity.class); SettlementEngineDetailsEntity engineEntity = mock(SettlementEngineDetailsEntity.class); when(entity.getSettlementEngineDetailsEntity()).thenReturn(engineEntity); String daveandbusters = "daveandbusters"; when(engineEntity.getSettlementEngineAccountId()).thenReturn(daveandbusters); AccountId mac = AccountId.of("mac"); when(entity.getAccountId()).thenReturn(mac); when(accountSettingsRepository.save(entity)) .thenThrow(new AccountSettlementEngineAlreadyExistsProblem(mac, daveandbusters)); expectedException.expect(AccountSettlementEngineAlreadyExistsProblem.class); expectedException.expectMessage("Account Settlement Engine Already Exists " + "[accountId: `" + mac.value() + "`, settlementEngineId: `" + daveandbusters + "`]"); accountManager.persistAccountSettingsEntity(entity); } |
DefaultAccountManager implements AccountManager { @Override public AccountSettings validateLinkSettings(AccountSettings accountSettings) { try { LinkSettings linkSettings = linkSettingsValidator .validateSettings(linkSettingsFactory.constructTyped(accountSettings)); if (accountSettings.linkType().equals(IlpOverHttpLink.LINK_TYPE)) { IlpOverHttpLinkSettings ilpOverHttpLinkSettings = (IlpOverHttpLinkSettings) linkSettings; return AccountSettings.builder() .from(accountSettings) .customSettings(ilpOverHttpLinkSettings.getCustomSettings()) .build(); } return accountSettings; } catch (IllegalArgumentException e) { throw new InvalidAccountSettingsProblem(e.getMessage(), accountSettings.accountId()); } } DefaultAccountManager(
final Supplier<ConnectorSettings> connectorSettingsSupplier,
final ConversionService conversionService,
final AccountSettingsRepository accountSettingsRepository,
final DeletedAccountSettingsRepository deletedAccountSettingsRepository,
final LinkManager linkManager,
final SettlementEngineClient settlementEngineClient,
final LinkSettingsFactory linkSettingsFactory,
final LinkSettingsValidator linkSettingsValidator,
final IldcpFetcherFactory ildcpFetcherFactory,
final EventBus eventBus
); @Override LinkManager getLinkManager(); @Override Optional<AccountSettings> findAccountById(AccountId accountId); @Override List<AccountSettings> getAccounts(); @Override AccountSettings createAccount(final AccountSettings accountSettings); @Override AccountSettings updateAccount(final AccountId accountId, final AccountSettings accountSettings); @Override AccountSettings validateLinkSettings(AccountSettings accountSettings); @Override AccountSettings initializeParentAccountSettingsViaIlDcp(final AccountId accountId); @Override @Transactional void deleteByAccountId(AccountId accountId); } | @Test public void validateLinkSettingsFailsOnInvalidLinkType() { AccountSettings accountSettings = AccountSettings.builder() .accountId(AccountId.of("UnsupportedLinkTypeGuy")) .assetCode("XRP") .assetScale(9) .linkType(LinkType.of("UnsupportedLinkType")) .accountRelationship(AccountRelationship.PEER) .build(); expectedException.expect(InvalidAccountSettingsProblem.class); expectedException.expectMessage("Unsupported LinkType:"); when(linkSettingsFactory.constructTyped(accountSettings)).thenThrow(new IllegalArgumentException("Unsupported LinkType: " + accountSettings.linkType())); accountManager.validateLinkSettings(accountSettings); } |
DefaultAccountManager implements AccountManager { @Override @Transactional public void deleteByAccountId(AccountId accountId) { Optional<AccountSettingsEntity> entity = accountSettingsRepository.findByAccountId(accountId); if (!entity.isPresent()) { throw new AccountNotFoundProblem(accountId); } deletedAccountSettingsRepository.save(new DeletedAccountSettingsEntity(entity.get())); accountSettingsRepository.delete(entity.get()); } DefaultAccountManager(
final Supplier<ConnectorSettings> connectorSettingsSupplier,
final ConversionService conversionService,
final AccountSettingsRepository accountSettingsRepository,
final DeletedAccountSettingsRepository deletedAccountSettingsRepository,
final LinkManager linkManager,
final SettlementEngineClient settlementEngineClient,
final LinkSettingsFactory linkSettingsFactory,
final LinkSettingsValidator linkSettingsValidator,
final IldcpFetcherFactory ildcpFetcherFactory,
final EventBus eventBus
); @Override LinkManager getLinkManager(); @Override Optional<AccountSettings> findAccountById(AccountId accountId); @Override List<AccountSettings> getAccounts(); @Override AccountSettings createAccount(final AccountSettings accountSettings); @Override AccountSettings updateAccount(final AccountId accountId, final AccountSettings accountSettings); @Override AccountSettings validateLinkSettings(AccountSettings accountSettings); @Override AccountSettings initializeParentAccountSettingsViaIlDcp(final AccountId accountId); @Override @Transactional void deleteByAccountId(AccountId accountId); } | @Test public void deleteAccount() { AccountId accountId = AccountId.of("egg"); final AccountSettings accountSettings = AccountSettings.builder() .accountId(accountId) .assetCode("XRP") .assetScale(9) .linkType(LinkType.of("Loopback")) .accountRelationship(AccountRelationship.PEER) .build(); AccountSettingsEntity account = new AccountSettingsEntity(accountSettings); when(accountSettingsRepository.findByAccountId(accountId)).thenReturn(Optional.of(account)); accountManager.deleteByAccountId(accountId); verify(accountSettingsRepository, times(1)).findByAccountId(accountId); verify(deletedAccountSettingsRepository, times(1)) .save(new DeletedAccountSettingsEntity(account)); }
@Test public void deleteMissingAccountThrowsNotFound() { AccountId accountId = AccountId.of("egg"); when(accountSettingsRepository.findByAccountId(accountId)).thenReturn(Optional.empty()); expectedException.expect(AccountNotFoundProblem.class); accountManager.deleteByAccountId(accountId); } |
DefaultAccountManager implements AccountManager { @Override public AccountSettings updateAccount(final AccountId accountId, final AccountSettings accountSettings) { Objects.requireNonNull(accountId); Objects.requireNonNull(accountSettings); final AccountSettings updatedSettings = validateLinkSettings(accountSettings); return accountSettingsRepository.findByAccountId(accountId) .map(entity -> { entity.setAssetCode(updatedSettings.assetCode()); entity.setAssetScale(updatedSettings.assetScale()); entity.setAccountRelationship(updatedSettings.accountRelationship()); entity.setBalanceSettings( new AccountBalanceSettingsEntity(updatedSettings.balanceSettings()) ); entity.setConnectionInitiator(updatedSettings.isConnectionInitiator()); entity.setDescription(updatedSettings.description()); entity.setCustomSettings(updatedSettings.customSettings()); entity.setIlpAddressSegment(updatedSettings.ilpAddressSegment()); entity.setInternal(updatedSettings.isInternal()); entity.setLinkType(updatedSettings.linkType()); entity.setMaximumPacketAmount(updatedSettings.maximumPacketAmount().map(UnsignedLong::bigIntegerValue)); entity.setRateLimitSettings( new AccountRateLimitSettingsEntity(updatedSettings.rateLimitSettings()) ); entity.setReceiveRoutes(updatedSettings.isReceiveRoutes()); entity.setSendRoutes(updatedSettings.isSendRoutes()); AccountSettingsEntity saved = accountSettingsRepository.save(entity); eventBus.post(AccountUpdatedEvent.builder().accountId(saved.getAccountId()).build()); eventBus.post(AccountCredentialsUpdatedEvent.builder().accountId(saved.getAccountId()).build()); return saved; }) .map(entity -> this.conversionService.convert(entity, AccountSettings.class)) .orElseThrow(() -> new AccountNotFoundProblem(accountId)); } DefaultAccountManager(
final Supplier<ConnectorSettings> connectorSettingsSupplier,
final ConversionService conversionService,
final AccountSettingsRepository accountSettingsRepository,
final DeletedAccountSettingsRepository deletedAccountSettingsRepository,
final LinkManager linkManager,
final SettlementEngineClient settlementEngineClient,
final LinkSettingsFactory linkSettingsFactory,
final LinkSettingsValidator linkSettingsValidator,
final IldcpFetcherFactory ildcpFetcherFactory,
final EventBus eventBus
); @Override LinkManager getLinkManager(); @Override Optional<AccountSettings> findAccountById(AccountId accountId); @Override List<AccountSettings> getAccounts(); @Override AccountSettings createAccount(final AccountSettings accountSettings); @Override AccountSettings updateAccount(final AccountId accountId, final AccountSettings accountSettings); @Override AccountSettings validateLinkSettings(AccountSettings accountSettings); @Override AccountSettings initializeParentAccountSettingsViaIlDcp(final AccountId accountId); @Override @Transactional void deleteByAccountId(AccountId accountId); } | @Test public void updateAccount() { AccountId accountId = AccountId.of("lloyd"); LinkType linkType = IlpOverHttpLink.LINK_TYPE; IlpOverHttpLinkSettings unvalidatedSettings = IlpOverHttpLinkSettings.builder() .incomingLinkSettings(mock(IncomingLinkSettings.class)) .outgoingLinkSettings(mock(OutgoingLinkSettings.class)) .customSettings(ImmutableMap.of("foo", "bar")) .build(); IlpOverHttpLinkSettings validatedSettings = IlpOverHttpLinkSettings.builder() .incomingLinkSettings(mock(IncomingLinkSettings.class)) .outgoingLinkSettings(mock(OutgoingLinkSettings.class)) .customSettings(ImmutableMap.of("fizz", "buzz")) .build(); final AccountSettings accountSettings = AccountSettings.builder() .accountId(accountId) .assetCode("XRP") .assetScale(9) .linkType(linkType) .accountRelationship(AccountRelationship.PEER) .customSettings(unvalidatedSettings.getCustomSettings()) .build(); AccountSettingsEntity account = new AccountSettingsEntity(accountSettings); final AccountSettings expectedUpdatedSettings = AccountSettings.builder() .from(accountSettings) .customSettings(validatedSettings.getCustomSettings()) .build(); AccountSettingsEntity expectedEntityToUpdate = new AccountSettingsEntity(expectedUpdatedSettings); when(accountSettingsRepository.findByAccountId(accountId)).thenReturn(Optional.of(account)); when(accountSettingsRepository.save( argThat((arg) -> arg.getCustomSettings().equals(validatedSettings.getCustomSettings())))) .thenReturn(expectedEntityToUpdate); when(linkSettingsValidator.validateSettings(unvalidatedSettings)).thenReturn(validatedSettings); when(linkSettingsFactory.constructTyped(accountSettings)).thenReturn(unvalidatedSettings); when(conversionService.convert(expectedEntityToUpdate, AccountSettings.class)).thenReturn(expectedUpdatedSettings); AccountSettings updated = accountManager.updateAccount(accountId, accountSettings); assertThat(updated).isEqualTo(expectedUpdatedSettings); verify(accountSettingsRepository, times(1)).findByAccountId(accountId); verify(accountSettingsRepository, times(1)).save(expectedEntityToUpdate); } |
DefaultAccountManager implements AccountManager { @Override public AccountSettings initializeParentAccountSettingsViaIlDcp(final AccountId accountId) { Objects.requireNonNull(accountId); final AccountSettingsEntity parentAccountSettingsEntity = accountSettingsRepository.safeFindByAccountId(accountId); final Link<?> link = this.getLinkManager().getOrCreateLink( conversionService.convert(parentAccountSettingsEntity, AccountSettings.class) ); final IldcpResponse ildcpResponse = ildcpFetcherFactory.construct(link).fetch(IldcpRequest.builder().build()); if (this.connectorSettingsSupplier.get() instanceof ModifiableConnectorSettings) { ((ModifiableConnectorSettings) this.connectorSettingsSupplier.get()) .setOperatorAddress(ildcpResponse.getClientAddress()); } else if (this.connectorSettingsSupplier.get() instanceof ConnectorSettingsFromPropertyFile) { ((ConnectorSettingsFromPropertyFile) this.connectorSettingsSupplier.get()) .setNodeIlpAddress(ildcpResponse.getClientAddress()); } parentAccountSettingsEntity.setAssetCode(ildcpResponse.getAssetCode()); parentAccountSettingsEntity.setAssetScale(ildcpResponse.getAssetScale()); final AccountSettingsEntity updatedAccountSettings = accountSettingsRepository.save(parentAccountSettingsEntity); logger.info( "IL-DCP Succeeded! Operator Address: `{}`", connectorSettingsSupplier.get().operatorAddress() ); return conversionService.convert(updatedAccountSettings, AccountSettings.class); } DefaultAccountManager(
final Supplier<ConnectorSettings> connectorSettingsSupplier,
final ConversionService conversionService,
final AccountSettingsRepository accountSettingsRepository,
final DeletedAccountSettingsRepository deletedAccountSettingsRepository,
final LinkManager linkManager,
final SettlementEngineClient settlementEngineClient,
final LinkSettingsFactory linkSettingsFactory,
final LinkSettingsValidator linkSettingsValidator,
final IldcpFetcherFactory ildcpFetcherFactory,
final EventBus eventBus
); @Override LinkManager getLinkManager(); @Override Optional<AccountSettings> findAccountById(AccountId accountId); @Override List<AccountSettings> getAccounts(); @Override AccountSettings createAccount(final AccountSettings accountSettings); @Override AccountSettings updateAccount(final AccountId accountId, final AccountSettings accountSettings); @Override AccountSettings validateLinkSettings(AccountSettings accountSettings); @Override AccountSettings initializeParentAccountSettingsViaIlDcp(final AccountId accountId); @Override @Transactional void deleteByAccountId(AccountId accountId); } | @Test public void initializeParentAccountSettingsViaIlDcpWithModifiableConfig() { ModifiableConnectorSettings modifiableConnectorSettings = ModifiableConnectorSettings.create(); InterledgerAddress ildcpAddress = InterledgerAddress.of("g.parent.child"); AccountId accountId = simulateIldcp(modifiableConnectorSettings, ildcpAddress); assertThat(modifiableConnectorSettings.operatorAddress()).isEqualTo(InterledgerAddress.of("self.node")); accountManager.initializeParentAccountSettingsViaIlDcp(accountId); assertThat(modifiableConnectorSettings.operatorAddress()).isEqualTo(ildcpAddress); }
@Test public void initializeParentAccountSettingsViaIlDcpWithPropertiesConfig() { ConnectorSettingsFromPropertyFile connectorSettingsFromPropertyFile = new ConnectorSettingsFromPropertyFile(); InterledgerAddress ildcpAddress = InterledgerAddress.of("g.parent.child"); AccountId accountId = simulateIldcp(connectorSettingsFromPropertyFile, ildcpAddress); assertThat(connectorSettingsFromPropertyFile.operatorAddress()).isEqualTo(InterledgerAddress.of("self.node")); accountManager.initializeParentAccountSettingsViaIlDcp(accountId); assertThat(connectorSettingsFromPropertyFile.operatorAddress()).isEqualTo(ildcpAddress); } |
ApplicationContextProvider implements ApplicationContextAware { public static Set<ApplicationContext> getAllApplicationContexts() { return findActiveContexts(ctx); } static Set<ApplicationContext> getAllApplicationContexts(); void setApplicationContext(ApplicationContext ctx); } | @Test public void getAllApplicationContexts() { assertThat(ApplicationContextProvider.findActiveContexts( Sets.newHashSet(mockContext(() -> false), mockContext(() -> false)))).hasSize(0); assertThat(ApplicationContextProvider.findActiveContexts( Sets.newHashSet(mockContext(() -> true), mockContext(() -> false)))).hasSize(1); assertThat(ApplicationContextProvider.findActiveContexts( Sets.newHashSet(mockContext(() -> true), mockContext(() -> true)))).hasSize(2); } |
StreamPacketUtils { public static Optional<Denomination> getDenomination(StreamPacket streamPacket) { return streamPacket.frames().stream() .filter(frame -> frame.streamFrameType().equals(StreamFrameType.ConnectionAssetDetails)) .map(frame -> ((ConnectionAssetDetailsFrame) frame)) .map(ConnectionAssetDetailsFrame::sourceDenomination) .findFirst(); } static Optional<Denomination> getDenomination(StreamPacket streamPacket); static boolean hasCloseFrame(StreamPacket streamPacket); static Optional<InterledgerAddress> getSourceAddress(StreamPacket streamPacket); } | @Test public void getDenomination() { assertThat(StreamPacketUtils.getDenomination(JUST_CONNECTION_ASSET_DETAILS_FRAME)).hasValue(DENOMINATION); assertThat(StreamPacketUtils.getDenomination(ALL_THE_FRAMES)).hasValue(DENOMINATION); assertThat(StreamPacketUtils.getDenomination(JUST_MONEY_FRAME)).isEmpty(); assertThat(StreamPacketUtils.getDenomination(NO_FRAMES)).isEmpty(); } |
StreamPacketUtils { public static boolean hasCloseFrame(StreamPacket streamPacket) { return streamPacket.frames().stream() .map(StreamFrame::streamFrameType) .anyMatch(CLOSING_FRAMES::contains); } static Optional<Denomination> getDenomination(StreamPacket streamPacket); static boolean hasCloseFrame(StreamPacket streamPacket); static Optional<InterledgerAddress> getSourceAddress(StreamPacket streamPacket); } | @Test public void hasCloseFrame() { assertThat(StreamPacketUtils.hasCloseFrame(JUST_CLOSE_FRAME)).isTrue(); assertThat(StreamPacketUtils.hasCloseFrame(ALL_THE_FRAMES)).isTrue(); assertThat(StreamPacketUtils.hasCloseFrame(JUST_MONEY_FRAME)).isFalse(); assertThat(StreamPacketUtils.hasCloseFrame(NO_FRAMES)).isFalse(); } |
StreamPacketUtils { public static Optional<InterledgerAddress> getSourceAddress(StreamPacket streamPacket) { return streamPacket.frames().stream() .filter(frame -> frame.streamFrameType().equals(StreamFrameType.ConnectionNewAddress)) .map(frame -> ((ConnectionNewAddressFrame) frame).sourceAddress()) .filter(Optional::isPresent) .map(Optional::get) .findFirst(); } static Optional<Denomination> getDenomination(StreamPacket streamPacket); static boolean hasCloseFrame(StreamPacket streamPacket); static Optional<InterledgerAddress> getSourceAddress(StreamPacket streamPacket); } | @Test public void getSourceAddress() { assertThat(StreamPacketUtils.getSourceAddress(JUST_CONNECTION_NEW_ADDRESS_FRAME)).hasValue(ADDRESS); assertThat(StreamPacketUtils.getSourceAddress(ALL_THE_FRAMES)).hasValue(ADDRESS); assertThat(StreamPacketUtils.getSourceAddress(JUST_MONEY_FRAME)).isEmpty(); assertThat(StreamPacketUtils.getSourceAddress(NO_FRAMES)).isEmpty(); } |
DefaultGcpPacketResponseEventPublisher implements GcpPacketResponseEventPublisher { @Override public void publish(PacketFullfillmentEvent event) { logger.debug("Received fulfillment"); fulfillmentTopic.ifPresent(topicName -> { try { GcpPacketResponseEvent gcpFulfillmentEvent = mapFulfillment(event); String payload = mapper.writerFor(GcpPacketResponseEvent.class).writeValueAsString(gcpFulfillmentEvent); template.publish(topicName, payload); } catch (JsonProcessingException e) { logger.warn("Could not serialize event ", e); } }); } DefaultGcpPacketResponseEventPublisher(PubSubTemplate template,
Optional<String> fulfillmentTopic,
Optional<String> rejectionTopic,
InterledgerAddress connectorAddress,
ObjectMapper mapper,
Clock clock); @Override void publish(PacketFullfillmentEvent event); @Override void publish(PacketRejectionEvent event); static final String STATUS_FULFILLED; static final String STATUS_REJECTED; } | @Test public void publishFulfillment() { AccountSettings incomingAccount = AccountSettings.builder() .accountId(AccountId.of("hugh_honey")) .accountRelationship(AccountRelationship.PEER) .assetScale(9) .assetCode("XRP") .linkType(IlpOverHttpLink.LINK_TYPE) .build(); AccountSettings destinationAccount = AccountSettings.builder() .accountId(AccountId.of("vic_vinegar")) .accountRelationship(AccountRelationship.PEER) .assetScale(2) .assetCode("USD") .linkType(IlpOverHttpLink.LINK_TYPE) .build(); InterledgerFulfillment fulfillment = InterledgerFulfillment.of(new byte[32]); InterledgerPreparePacket incomingPreparePacket = InterledgerPreparePacket.builder() .executionCondition(InterledgerCondition.of(new byte[32])) .amount(UnsignedLong.valueOf(100)) .destination(DEST_ADDRESS) .expiresAt(Instant.now().plusSeconds(1)) .build(); InterledgerPreparePacket outgoingPreparePacket = InterledgerPreparePacket.builder() .executionCondition(InterledgerCondition.of(new byte[32])) .amount(UnsignedLong.valueOf(123)) .destination(DEST_ADDRESS) .expiresAt(Instant.now().plusSeconds(2)) .build(); PacketFullfillmentEvent packetFulfillmentEvent = PacketFullfillmentEvent.builder() .exchangeRate(new BigDecimal("1.23")) .destinationAccount(destinationAccount) .fulfillment(fulfillment) .accountSettings(incomingAccount) .incomingPreparePacket(incomingPreparePacket) .outgoingPreparePacket(outgoingPreparePacket) .message("hello") .build(); publisher.publish(packetFulfillmentEvent); String expected = "{\"prevHopAccount\":\"hugh_honey\"," + "\"prevHopAssetCode\":\"XRP\"," + "\"prevHopAmount\":\"100\"," + "\"nextHopAccount\":\"vic_vinegar\"," + "\"nextHopAssetCode\":\"USD\"," + "\"nextHopAmount\":\"123\"," + "\"spread\":\"0\"," + "\"exchangeRate\":\"1.23\"," + "\"connectorIlpAddress\":\"test.hugh.honey\"," + "\"destinationIlpAddress\":\"test.vic.vinegar\"," + "\"fulfillment\":\"Zmh6rfhivXdsj8GLjp+OIAiXFIVu4jOzkCpZHQ1fKSU=\"," + "\"timestamp\":\"2000-01-02T03:04:05.678Z\"," + "\"prevHopAssetScale\":\"9\"," + "\"nextHopAssetScale\":\"2\"," + "\"status\":\"FULFILLED\"}"; verify(template).publish(FULFILLS, expected); }
@Test public void publishFulfillmentSkippedIfNotConfigured() { publisher = new DefaultGcpPacketResponseEventPublisher(template, Optional.empty(), Optional.of(REJECTS), OPERATOR_ADDRESS, mapper, clock); publisher.publish(mock(PacketFullfillmentEvent.class)); verifyNoInteractions(template); }
@Test public void publishRejectionFromNextHop() { AccountSettings incomingAccount = AccountSettings.builder() .accountId(AccountId.of("hugh_honey")) .accountRelationship(AccountRelationship.PEER) .assetScale(9) .assetCode("XRP") .linkType(IlpOverHttpLink.LINK_TYPE) .build(); AccountSettings destinationAccount = AccountSettings.builder() .accountId(AccountId.of("vic_vinegar")) .accountRelationship(AccountRelationship.PEER) .assetScale(2) .assetCode("USD") .linkType(IlpOverHttpLink.LINK_TYPE) .build(); InterledgerRejectPacket rejectPacket = InterledgerRejectPacket.builder() .code(InterledgerErrorCode.F05_WRONG_CONDITION) .triggeredBy(DEST_ADDRESS) .message("Epstein didn't kill himself") .build(); InterledgerPreparePacket incomingPreparePacket = InterledgerPreparePacket.builder() .executionCondition(InterledgerCondition.of(new byte[32])) .amount(UnsignedLong.valueOf(100)) .destination(DEST_ADDRESS) .expiresAt(Instant.now().plusSeconds(1)) .build(); InterledgerPreparePacket outgoingPreparePacket = InterledgerPreparePacket.builder() .executionCondition(InterledgerCondition.of(new byte[32])) .amount(UnsignedLong.valueOf(123)) .destination(DEST_ADDRESS) .expiresAt(Instant.now().plusSeconds(2)) .build(); PacketRejectionEvent packetRejectionEvent = PacketRejectionEvent.builder() .exchangeRate(new BigDecimal("1.23")) .destinationAccount(destinationAccount) .rejection(rejectPacket) .accountSettings(incomingAccount) .incomingPreparePacket(incomingPreparePacket) .outgoingPreparePacket(outgoingPreparePacket) .message("event message") .build(); publisher.publish(packetRejectionEvent); String expected = "{\"prevHopAccount\":\"hugh_honey\"," + "\"prevHopAssetCode\":\"XRP\"," + "\"prevHopAmount\":\"100\"," + "\"nextHopAccount\":\"vic_vinegar\"," + "\"nextHopAssetCode\":\"USD\"," + "\"nextHopAmount\":\"123\"," + "\"spread\":\"0\"," + "\"exchangeRate\":\"1.23\"," + "\"connectorIlpAddress\":\"test.hugh.honey\"," + "\"destinationIlpAddress\":\"test.vic.vinegar\"," + "\"timestamp\":\"2000-01-02T03:04:05.678Z\"," + "\"prevHopAssetScale\":\"9\"," + "\"nextHopAssetScale\":\"2\"," + "\"status\":\"REJECTED\"," + "\"rejectionMessage\":\"Epstein didn't kill himself\"," + "\"rejectionCode\":\"F05\"," + "\"rejectionTriggeredBy\":\"test.vic.vinegar\"}"; verify(template).publish(REJECTS, expected); }
@Test public void publishRejectionFromCurrentHop() { AccountSettings incomingAccount = AccountSettings.builder() .accountId(AccountId.of("hugh_honey")) .accountRelationship(AccountRelationship.PEER) .assetScale(9) .assetCode("XRP") .linkType(IlpOverHttpLink.LINK_TYPE) .build(); InterledgerRejectPacket rejectPacket = InterledgerRejectPacket.builder() .code(InterledgerErrorCode.F05_WRONG_CONDITION) .triggeredBy(DEST_ADDRESS) .message("Epstein didn't kill himself") .build(); InterledgerPreparePacket incomingPreparePacket = InterledgerPreparePacket.builder() .executionCondition(InterledgerCondition.of(new byte[32])) .amount(UnsignedLong.valueOf(100)) .destination(DEST_ADDRESS) .expiresAt(Instant.now().plusSeconds(1)) .build(); PacketRejectionEvent packetRejectionEvent = PacketRejectionEvent.builder() .rejection(rejectPacket) .accountSettings(incomingAccount) .incomingPreparePacket(incomingPreparePacket) .message("event message") .build(); publisher.publish(packetRejectionEvent); String expected = "{\"prevHopAccount\":\"hugh_honey\"," + "\"prevHopAssetCode\":\"XRP\"," + "\"prevHopAmount\":\"100\"," + "\"spread\":\"0\"," + "\"connectorIlpAddress\":\"test.hugh.honey\"," + "\"destinationIlpAddress\":\"test.vic.vinegar\"," + "\"timestamp\":\"2000-01-02T03:04:05.678Z\"," + "\"prevHopAssetScale\":\"9\"," + "\"status\":\"REJECTED\"," + "\"rejectionMessage\":\"Epstein didn't kill himself\"," + "\"rejectionCode\":\"F05\"," + "\"rejectionTriggeredBy\":\"test.vic.vinegar\"}"; verify(template).publish(REJECTS, expected); }
@Test public void publishRejectionSkippedIfNotConfigured() { publisher = new DefaultGcpPacketResponseEventPublisher(template, Optional.of(FULFILLS), Optional.empty(), OPERATOR_ADDRESS, mapper, clock); publisher.publish(mock(PacketRejectionEvent.class)); verifyNoInteractions(template); } |
AccountBalanceService { public AccountBalanceResponse getAccountBalance(final AccountId accountId) { Objects.requireNonNull(accountId); return accountSettingsRepository.findByAccountIdWithConversion(accountId) .map(settings -> AccountBalanceResponse.builder() .accountBalance(balanceTracker.balance(accountId)) .assetCode(settings.assetCode()) .assetScale((short) settings.assetScale()) .build() ).orElseThrow(() -> new AccountNotFoundProblem(accountId)); } AccountBalanceService(
final BalanceTracker balanceTracker, final AccountSettingsRepository accountSettingsRepository
); AccountBalanceResponse getAccountBalance(final AccountId accountId); } | @Test public void getAccountBalance() { AccountId accountId = AccountId.of("test"); AccountSettings settings = AccountSettings.builder() .accountId(accountId) .description("child") .accountRelationship(AccountRelationship.CHILD) .linkType(IlpOverHttpLink.LINK_TYPE) .assetScale(2) .assetCode("XRP") .build(); AccountBalance balance = AccountBalance.builder() .accountId(accountId) .clearingBalance(1) .prepaidAmount(2) .build(); AccountBalanceResponse expected = AccountBalanceResponse.builder() .accountBalance(balance) .assetScale(settings.assetScale()) .assetCode(settings.assetCode()) .build(); when(mockSettingsRepo.findByAccountIdWithConversion(accountId)).thenReturn(Optional.of(settings)); when(mockBalanceTracker.balance(accountId)).thenReturn(balance); AccountBalanceResponse response = service.getAccountBalance(accountId); assertThat(response).isEqualTo(expected); }
@Test public void getAccountBalanceAccountNotFound() { AccountId accountId = AccountId.of("test"); when(mockSettingsRepo.findByAccountIdWithConversion(accountId)).thenReturn(Optional.empty()); expectedException.expect(AccountNotFoundProblem.class); service.getAccountBalance(accountId); } |
ApplicationContextProvider implements ApplicationContextAware { @VisibleForTesting static Set<ApplicationContext> findActiveContexts(Set<ApplicationContext> contexts) { return contexts.stream() .filter(ctx -> ctx instanceof ConfigurableApplicationContext) .map(ctx -> (ConfigurableApplicationContext) ctx) .filter(ctx -> ctx.isActive()) .collect(Collectors.toSet()); } static Set<ApplicationContext> getAllApplicationContexts(); void setApplicationContext(ApplicationContext ctx); } | @Test public void getAllApplicationContextsWithChangingValue() { AtomicBoolean active = new AtomicBoolean(false); HashSet<ApplicationContext> contexts = Sets.newHashSet(mockContext(() -> active.get()), mockContext(() -> false)); assertThat(ApplicationContextProvider.findActiveContexts(contexts)).hasSize(0); active.set(true); assertThat(ApplicationContextProvider.findActiveContexts(contexts)).hasSize(1); active.set(false); assertThat(ApplicationContextProvider.findActiveContexts(contexts)).hasSize(0); } |
DefaultPacketEventPublisher implements PacketEventPublisher { @Override public void publishRejectionByNextHop(AccountSettings sourceAccountSettings, AccountSettings nextHopAccountSettings, InterledgerPreparePacket preparePacket, InterledgerPreparePacket nextHopPacket, BigDecimal fxRate, InterledgerRejectPacket rejectPacket) { eventBus.post(PacketRejectionEvent.builder() .accountSettings(sourceAccountSettings) .destinationAccount(nextHopAccountSettings) .exchangeRate(fxRate) .incomingPreparePacket(preparePacket) .outgoingPreparePacket(nextHopPacket) .message(rejectPacket.getMessage()) .rejection(rejectPacket) .build()); } DefaultPacketEventPublisher(EventBus eventBus); @Override void publishRejectionByNextHop(AccountSettings sourceAccountSettings,
AccountSettings nextHopAccountSettings,
InterledgerPreparePacket preparePacket,
InterledgerPreparePacket nextHopPacket,
BigDecimal fxRate,
InterledgerRejectPacket rejectPacket); @Override void publishRejectionByConnector(AccountSettings sourceAccountSettings,
InterledgerPreparePacket preparePacket,
InterledgerRejectPacket rejectPacket); @Override void publishFulfillment(AccountSettings sourceAccountSettings,
AccountSettings nextHopAccountSettings,
InterledgerPreparePacket preparePacket,
InterledgerPreparePacket nextHopPacket,
BigDecimal fxRate,
InterledgerFulfillment fulfillment); } | @Test public void publishRejectionByNextHop() { publisher.publishRejectionByNextHop(sourceAccountSettings, nextHopAccountSettings, preparePacket, nextHopPacket, fxRate, rejectPacket); verify(eventBus).post(PacketRejectionEvent.builder() .accountSettings(sourceAccountSettings) .destinationAccount(nextHopAccountSettings) .exchangeRate(fxRate) .incomingPreparePacket(preparePacket) .outgoingPreparePacket(nextHopPacket) .rejection(rejectPacket) .message(rejectPacket.getMessage()) .build() ); } |
DefaultPacketEventPublisher implements PacketEventPublisher { @Override public void publishRejectionByConnector(AccountSettings sourceAccountSettings, InterledgerPreparePacket preparePacket, InterledgerRejectPacket rejectPacket) { eventBus.post(PacketRejectionEvent.builder() .accountSettings(sourceAccountSettings) .incomingPreparePacket(preparePacket) .message(rejectPacket.getMessage()) .rejection(rejectPacket) .build()); } DefaultPacketEventPublisher(EventBus eventBus); @Override void publishRejectionByNextHop(AccountSettings sourceAccountSettings,
AccountSettings nextHopAccountSettings,
InterledgerPreparePacket preparePacket,
InterledgerPreparePacket nextHopPacket,
BigDecimal fxRate,
InterledgerRejectPacket rejectPacket); @Override void publishRejectionByConnector(AccountSettings sourceAccountSettings,
InterledgerPreparePacket preparePacket,
InterledgerRejectPacket rejectPacket); @Override void publishFulfillment(AccountSettings sourceAccountSettings,
AccountSettings nextHopAccountSettings,
InterledgerPreparePacket preparePacket,
InterledgerPreparePacket nextHopPacket,
BigDecimal fxRate,
InterledgerFulfillment fulfillment); } | @Test public void publishRejectionByConnector() { publisher.publishRejectionByConnector(sourceAccountSettings, preparePacket, rejectPacket); verify(eventBus).post(PacketRejectionEvent.builder() .accountSettings(sourceAccountSettings) .incomingPreparePacket(preparePacket) .rejection(rejectPacket) .message(rejectPacket.getMessage()) .build() ); } |
DefaultPacketEventPublisher implements PacketEventPublisher { @Override public void publishFulfillment(AccountSettings sourceAccountSettings, AccountSettings nextHopAccountSettings, InterledgerPreparePacket preparePacket, InterledgerPreparePacket nextHopPacket, BigDecimal fxRate, InterledgerFulfillment fulfillment) { eventBus.post(PacketFullfillmentEvent.builder() .accountSettings(sourceAccountSettings) .destinationAccount(nextHopAccountSettings) .exchangeRate(fxRate) .incomingPreparePacket(preparePacket) .outgoingPreparePacket(nextHopPacket) .fulfillment(fulfillment) .message("Fulfilled successfully") .build()); } DefaultPacketEventPublisher(EventBus eventBus); @Override void publishRejectionByNextHop(AccountSettings sourceAccountSettings,
AccountSettings nextHopAccountSettings,
InterledgerPreparePacket preparePacket,
InterledgerPreparePacket nextHopPacket,
BigDecimal fxRate,
InterledgerRejectPacket rejectPacket); @Override void publishRejectionByConnector(AccountSettings sourceAccountSettings,
InterledgerPreparePacket preparePacket,
InterledgerRejectPacket rejectPacket); @Override void publishFulfillment(AccountSettings sourceAccountSettings,
AccountSettings nextHopAccountSettings,
InterledgerPreparePacket preparePacket,
InterledgerPreparePacket nextHopPacket,
BigDecimal fxRate,
InterledgerFulfillment fulfillment); } | @Test public void publishFulfillment() { publisher.publishFulfillment(sourceAccountSettings, nextHopAccountSettings, preparePacket, nextHopPacket, fxRate, fulfillment); verify(eventBus).post(PacketFullfillmentEvent.builder() .accountSettings(sourceAccountSettings) .destinationAccount(nextHopAccountSettings) .outgoingPreparePacket(nextHopPacket) .incomingPreparePacket(preparePacket) .exchangeRate(fxRate) .fulfillment(fulfillment) .message("Fulfilled successfully") .build() ); } |
DefaultILPv4PacketSwitch implements ILPv4PacketSwitch { public final InterledgerResponsePacket switchPacket( final AccountId sourceAccountId, final InterledgerPreparePacket incomingSourcePreparePacket ) { Objects.requireNonNull(sourceAccountId); Objects.requireNonNull(incomingSourcePreparePacket); return this.accountSettingsLoadingCache.getAccount(sourceAccountId) .map(accountSettings -> { try { return new DefaultPacketSwitchFilterChain( packetRejector, packetSwitchFilters, linkFilters, localDestinationAddressUtils, linkManager, nextHopPacketMapper, accountSettingsLoadingCache, packetEventPublisher ).doFilter(accountSettings, incomingSourcePreparePacket); } catch (Exception e) { return this.connectorExceptionHandler.handleException(accountSettings, incomingSourcePreparePacket, e); } }) .orElseThrow(() -> { return new InterledgerProtocolException( packetRejector.reject( LinkId.of(sourceAccountId.value()), incomingSourcePreparePacket, InterledgerErrorCode.T00_INTERNAL_ERROR, String.format("No Account found: `%s`", sourceAccountId)) ); }); } DefaultILPv4PacketSwitch(
final List<PacketSwitchFilter> packetSwitchFilters,
final List<LinkFilter> linkFilters,
final LinkManager linkManager,
final NextHopPacketMapper nextHopPacketMapper,
final ConnectorExceptionHandler connectorExceptionHandler,
final PacketRejector packetRejector,
final AccountSettingsLoadingCache accountSettingsLoadingCache,
final PacketEventPublisher packetEventPublisher,
final LocalDestinationAddressUtils localDestinationAddressUtils
); final InterledgerResponsePacket switchPacket(
final AccountId sourceAccountId, final InterledgerPreparePacket incomingSourcePreparePacket
); } | @Test public void switchPacketWithNoAccount() { final AccountId NON_EXISTENT_ACCOUNT_ID = AccountId.of("123"); final LinkId NON_EXISTENT_LINK_ID = LinkId.of(NON_EXISTENT_ACCOUNT_ID.value()); when(accountSettingsLoadingCacheMock.getAccount(any())).thenReturn(Optional.empty()); final InterledgerRejectPacket rejectPacket = InterledgerRejectPacket.builder() .code(T00_INTERNAL_ERROR) .message("") .build(); when(packetRejectorMock.reject(any(), any(), any(), anyString())).thenReturn(rejectPacket); expectedException.expect(InterledgerProtocolException.class); try { packetSwitch.switchPacket(NON_EXISTENT_ACCOUNT_ID, PREPARE_PACKET); fail("Should have thrown an InterledgerProtocolException!"); } catch (InterledgerProtocolException e) { verify(packetRejectorMock).reject( eq(NON_EXISTENT_LINK_ID), eq(PREPARE_PACKET), eq(T00_INTERNAL_ERROR), eq("No Account found: `123`") ); assertThat(e.getInterledgerRejectPacket()).isEqualTo(rejectPacket); verify(accountSettingsLoadingCacheMock).getAccount(eq(NON_EXISTENT_ACCOUNT_ID)); verifyNoInteractions(connectorExceptionHandlerMock); verifyNoInteractions(nextHopPacketMapperMock); verifyNoInteractions(linkFiltersMock); verifyNoInteractions(linkManagerMock); verifyNoInteractions(packetSwitchFiltersMock); verifyNoMoreInteractions(packetRejectorMock); throw e; } }
@Test public void switchPacketMultipleTimeWithSameAccount() { final ImmutableAccountSettings incomingAccountSettings = AccountSettings.builder() .accountId(INCOMING_ACCOUNT_ID) .accountRelationship(AccountRelationship.PEER) .assetCode("USD") .assetScale(2) .linkType(LoopbackLink.LINK_TYPE) .build(); when(accountSettingsLoadingCacheMock.getAccount(INCOMING_ACCOUNT_ID)) .thenReturn(Optional.of(incomingAccountSettings)); final ImmutableAccountSettings outgoingAccountSettings = AccountSettings.builder() .accountId(OUTGOING_ACCOUNT_ID) .accountRelationship(AccountRelationship.PEER) .assetCode("USD") .assetScale(2) .linkType(LoopbackLink.LINK_TYPE) .build(); when(accountSettingsLoadingCacheMock.getAccount(OUTGOING_ACCOUNT_ID)) .thenReturn(Optional.of(outgoingAccountSettings)); final NextHopInfo nextHopInfo = NextHopInfo.builder() .nextHopAccountId(OUTGOING_ACCOUNT_ID) .nextHopPacket(PREPARE_PACKET) .build(); when(nextHopPacketMapperMock.getNextHopPacket(eq(incomingAccountSettings), eq(PREPARE_PACKET))) .thenReturn(nextHopInfo); when(linkManagerMock.getOrCreateLink(outgoingAccountSettings)).thenReturn(outgoingLink); when(nextHopPacketMapperMock.determineExchangeRate(any(), any(), any())).thenReturn(BigDecimal.ZERO); final int numReps = 5; for (int i = 0; i < numReps; i++) { packetSwitch.switchPacket(INCOMING_ACCOUNT_ID, PREPARE_PACKET).handle( fulfillPacket -> assertThat(fulfillPacket.getFulfillment()).isEqualTo(LoopbackLink.LOOPBACK_FULFILLMENT), rejectPacket -> fail("Should have fulfilled but rejected!") ); } verify(packetSwitchFiltersMock, times(numReps)).size(); verify(linkFiltersMock, times(numReps)).size(); verify(linkManagerMock, times(numReps)).getOrCreateLink(outgoingAccountSettings); verify(nextHopPacketMapperMock, times(numReps)).getNextHopPacket(incomingAccountSettings, PREPARE_PACKET); verify(accountSettingsLoadingCacheMock, times(10)).getAccount(any()); verify(nextHopPacketMapperMock, times(numReps)).determineExchangeRate(any(), any(), any()); verifyNoInteractions(connectorExceptionHandlerMock); verifyNoInteractions(packetRejectorMock); verifyNoMoreInteractions(packetSwitchFiltersMock); verifyNoMoreInteractions(nextHopPacketMapperMock); verifyNoMoreInteractions(linkFiltersMock); verifyNoMoreInteractions(accountSettingsLoadingCacheMock); }
@Test public void switchPacketMultipleTimeWithDifferentAccounts() { final int numReps = 5; for (int i = 0; i < numReps; i++) { final AccountId incomingAccountID = AccountId.of(INCOMING_ACCOUNT_ID.value() + i); final AccountId outgoingAccountID = AccountId.of(OUTGOING_ACCOUNT_ID.value() + i); final AccountSettings incomingAccountSettings = AccountSettings.builder() .accountId(incomingAccountID) .accountRelationship(AccountRelationship.PEER) .assetCode("USD") .assetScale(2) .linkType(LoopbackLink.LINK_TYPE) .build(); final AccountSettings outgoingAccountSettings = AccountSettings.builder() .accountId(outgoingAccountID) .accountRelationship(AccountRelationship.PEER) .assetCode("USD") .assetScale(2) .linkType(LoopbackLink.LINK_TYPE) .build(); when(accountSettingsLoadingCacheMock.getAccount(incomingAccountID)) .thenReturn(Optional.of(incomingAccountSettings)); when(accountSettingsLoadingCacheMock.getAccount(outgoingAccountID)) .thenReturn(Optional.of(outgoingAccountSettings)); final NextHopInfo nextHopInfo = NextHopInfo.builder() .nextHopAccountId(outgoingAccountID) .nextHopPacket(PREPARE_PACKET) .build(); when(nextHopPacketMapperMock.getNextHopPacket(eq(incomingAccountSettings), eq(PREPARE_PACKET))) .thenReturn(nextHopInfo); when(linkManagerMock.getOrCreateLink(outgoingAccountSettings)).thenReturn(outgoingLink); when(nextHopPacketMapperMock.determineExchangeRate(any(), any(), any())).thenReturn(BigDecimal.ZERO); packetSwitch.switchPacket(incomingAccountID, PREPARE_PACKET).handle( fulfillPacket -> assertThat(fulfillPacket.getFulfillment()).isEqualTo(LoopbackLink.LOOPBACK_FULFILLMENT), rejectPacket -> fail("Should have fulfilled but rejected!") ); verify(linkManagerMock).getOrCreateLink(eq(outgoingAccountSettings)); verify(nextHopPacketMapperMock).getNextHopPacket(incomingAccountSettings, PREPARE_PACKET); verify(accountSettingsLoadingCacheMock, times(1)).getAccount(incomingAccountID); verify(accountSettingsLoadingCacheMock, times(1)).getAccount(outgoingAccountID); verify(nextHopPacketMapperMock).determineExchangeRate(eq(incomingAccountSettings), any(), eq(PREPARE_PACKET)); } verify(packetSwitchFiltersMock, times(numReps)).size(); verify(linkFiltersMock, times(numReps)).size(); verifyNoInteractions(connectorExceptionHandlerMock); verifyNoInteractions(packetRejectorMock); verifyNoMoreInteractions(linkManagerMock); verifyNoMoreInteractions(nextHopPacketMapperMock); verifyNoMoreInteractions(accountSettingsLoadingCacheMock); }
@Test public void switchExpiredPacket() { final ImmutableAccountSettings incomingAccountSettings = AccountSettings.builder() .accountId(INCOMING_ACCOUNT_ID) .accountRelationship(AccountRelationship.PEER) .assetCode("USD") .assetScale(2) .linkType(LoopbackLink.LINK_TYPE) .build(); when(accountSettingsLoadingCacheMock.getAccount(INCOMING_ACCOUNT_ID)) .thenReturn(Optional.of(incomingAccountSettings)); final ImmutableAccountSettings outgoingAccountSettings = AccountSettings.builder() .accountId(OUTGOING_ACCOUNT_ID) .accountRelationship(AccountRelationship.PEER) .assetCode("USD") .assetScale(2) .linkType(LoopbackLink.LINK_TYPE) .build(); when(accountSettingsLoadingCacheMock.getAccount(OUTGOING_ACCOUNT_ID)) .thenReturn(Optional.of(outgoingAccountSettings)); final NextHopInfo nextHopInfo = NextHopInfo.builder() .nextHopAccountId(OUTGOING_ACCOUNT_ID) .nextHopPacket(PREPARE_PACKET) .build(); when(nextHopPacketMapperMock.getNextHopPacket(eq(incomingAccountSettings), eq(PREPARE_PACKET))) .thenReturn(nextHopInfo); when(linkManagerMock.getOrCreateLink(outgoingAccountSettings)).thenReturn(outgoingLink); when(nextHopPacketMapperMock.determineExchangeRate(any(), any(), any())).thenReturn(BigDecimal.ZERO); final AbstractInterledgerPreparePacket expiredPreparePacket = InterledgerPreparePacket .builder() .destination(InterledgerAddress.of("test.foo")) .amount(UnsignedLong.ONE) .expiresAt(Instant.MIN) .executionCondition(InterledgerCondition.of(new byte[32])) .build(); packetSwitch.switchPacket(INCOMING_ACCOUNT_ID, PREPARE_PACKET).handle( fulfillPacket -> assertThat(fulfillPacket.getFulfillment()).isEqualTo(LoopbackLink.LOOPBACK_FULFILLMENT), rejectPacket -> fail("Should have fulfilled but rejected!") ); verify(packetSwitchFiltersMock).size(); verify(linkFiltersMock).size(); verify(linkManagerMock).getOrCreateLink(outgoingAccountSettings); verify(nextHopPacketMapperMock).getNextHopPacket(incomingAccountSettings, PREPARE_PACKET); verify(accountSettingsLoadingCacheMock, times(2)).getAccount(any()); verify(nextHopPacketMapperMock).determineExchangeRate(any(), any(), any()); verifyNoInteractions(connectorExceptionHandlerMock); verifyNoInteractions(packetRejectorMock); verifyNoMoreInteractions(packetSwitchFiltersMock); verifyNoMoreInteractions(nextHopPacketMapperMock); verifyNoMoreInteractions(linkFiltersMock); verifyNoMoreInteractions(accountSettingsLoadingCacheMock); } |
RateLimitIlpPacketFilter extends AbstractPacketFilter implements PacketSwitchFilter { @Override public InterledgerResponsePacket doFilter( final AccountSettings sourceAccountSettings, final InterledgerPreparePacket sourcePreparePacket, final PacketSwitchFilterChain filterChain ) { return rateLimiters .get( sourceAccountSettings.accountId(), (key) -> sourceAccountSettings.rateLimitSettings().maxPacketsPerSecond().map(RateLimiter::create) ) .map(rateLimiter -> { if (rateLimiter.tryAcquire(1)) { return filterChain.doFilter(sourceAccountSettings, sourcePreparePacket); } else { this.metricsService.trackNumRateLimitedPackets(sourceAccountSettings); return packetRejector.reject( LinkId.of(sourceAccountSettings.accountId().value()), sourcePreparePacket, InterledgerErrorCode.T03_CONNECTOR_BUSY, "Rate Limit exceeded" ); } }) .orElseGet(() -> filterChain.doFilter(sourceAccountSettings, sourcePreparePacket)); } RateLimitIlpPacketFilter(
final PacketRejector packetRejector,
final MetricsService metricsService,
final Cache<AccountId, Optional<RateLimiter>> rateLimiterCache
); @Override InterledgerResponsePacket doFilter(
final AccountSettings sourceAccountSettings,
final InterledgerPreparePacket sourcePreparePacket,
final PacketSwitchFilterChain filterChain
); } | @Test public void doFilterWithNoAccount() { when(cacheMock.get(any(), any())).thenReturn(Optional.empty()); filter.doFilter(accountSettingsMock, PREPARE_PACKET, filterChainMock); filter.doFilter(accountSettingsMock, PREPARE_PACKET, filterChainMock); filter.doFilter(accountSettingsMock, PREPARE_PACKET, filterChainMock); }
@Test public void doFilterWithNoMaxPacketAmount() { when(cacheMock.get(any(), any())).thenReturn(Optional.of(rateLimiterMock)); when(rateLimiterMock.tryAcquire(1)).thenReturn(true); when(rateLimitSettingsMock.maxPacketsPerSecond()).thenReturn(Optional.empty()); InterledgerResponsePacket response = filter.doFilter(accountSettingsMock, PREPARE_PACKET, filterChainMock); assertThat(response instanceof InterledgerFulfillPacket).isTrue(); response = filter.doFilter(accountSettingsMock, PREPARE_PACKET, filterChainMock); assertThat(response instanceof InterledgerFulfillPacket).as("Response was: " + response.getClass().getName()).isTrue(); response = filter.doFilter(accountSettingsMock, PREPARE_PACKET, filterChainMock); assertThat(response instanceof InterledgerFulfillPacket).as("Response was: " + response.getClass().getName()).isTrue(); verify(filterChainMock, times(3)).doFilter(accountSettingsMock, PREPARE_PACKET); }
@Test public void doFilterWithInsufficientTickets() { when(cacheMock.get(any(), any())).thenReturn(Optional.of(rateLimiterMock)); when(rateLimiterMock.acquire()).thenReturn(0.0); when(rateLimitSettingsMock.maxPacketsPerSecond()).thenReturn(Optional.of(1)); InterledgerResponsePacket response = filter.doFilter(accountSettingsMock, PREPARE_PACKET, filterChainMock); assertThat(response instanceof InterledgerRejectPacket).isTrue(); response = filter.doFilter(accountSettingsMock, PREPARE_PACKET, filterChainMock); assertThat(response instanceof InterledgerRejectPacket).isTrue(); response = filter.doFilter(accountSettingsMock, PREPARE_PACKET, filterChainMock); assertThat(response instanceof InterledgerRejectPacket).isTrue(); verifyNoInteractions(filterChainMock); verify(packetRejectorMock, times(3)).reject(any(), any(), any(), any()); }
@Test public void doFilterWithNoPermits() { when(cacheMock.get(any(), any())).thenReturn(Optional.of(rateLimiterMock)); when(rateLimiterMock.tryAcquire(1)).thenReturn(Boolean.FALSE); InterledgerResponsePacket response = filter.doFilter(accountSettingsMock, PREPARE_PACKET, filterChainMock); assertThat(response instanceof InterledgerRejectPacket).isTrue(); response = filter.doFilter(accountSettingsMock, PREPARE_PACKET, filterChainMock); assertThat(response instanceof InterledgerRejectPacket).isTrue(); verifyNoInteractions(filterChainMock); }
@Test public void doFilterWithPermit() { when(cacheMock.get(any(), any())).thenReturn(Optional.of(rateLimiterMock)); when(rateLimiterMock.tryAcquire(1)).thenReturn(true); InterledgerResponsePacket response = filter.doFilter(accountSettingsMock, PREPARE_PACKET, filterChainMock); assertThat(response instanceof InterledgerFulfillPacket).isTrue(); response = filter.doFilter(accountSettingsMock, PREPARE_PACKET, filterChainMock); assertThat(response instanceof InterledgerFulfillPacket).isTrue(); verify(filterChainMock, times(2)).doFilter(accountSettingsMock, PREPARE_PACKET); }
@Test public void doFilterWithNoRateLimiter() { when(cacheMock.get(any(), any())).thenReturn(Optional.empty()); InterledgerResponsePacket response = filter.doFilter(accountSettingsMock, PREPARE_PACKET, filterChainMock); assertThat(response instanceof InterledgerFulfillPacket).isTrue(); response = filter.doFilter(accountSettingsMock, PREPARE_PACKET, filterChainMock); assertThat(response instanceof InterledgerFulfillPacket).isTrue(); verify(filterChainMock, times(2)).doFilter(accountSettingsMock, PREPARE_PACKET); } |
SpringConnectorWebMvc implements WebMvcConfigurer { @Override public void extendMessageConverters(List<HttpMessageConverter<?>> converters) { converters.replaceAll(messageConverter -> { if (messageConverter instanceof MappingJackson2HttpMessageConverter) { if (((MappingJackson2HttpMessageConverter) messageConverter).getObjectMapper().getRegisteredModuleIds() .contains(ProblemModule.class.getName())) { return messageConverter; } return new MappingJackson2HttpMessageConverter(objectMapper); } else { return messageConverter; } }); } @Override void configureMessageConverters(List<HttpMessageConverter<?>> converters); @Override void extendMessageConverters(List<HttpMessageConverter<?>> converters); @Override void addFormatters(FormatterRegistry registry); } | @Test public void testExtendMessageConvertersWhenEmpty() { List<HttpMessageConverter<?>> messageConverters = Lists.newArrayList(); springConnectorWebMvc.extendMessageConverters(messageConverters); assertThat(messageConverters.size()).isEqualTo(0); }
@Test public void testExtendMessageConvertersWithoutProblemsJsonHttpConverters() { final List<HttpMessageConverter<?>> originalMessageConverters = configureInitialMessageConvertersWithoutProblems(); final List<HttpMessageConverter<?>> adjustedMessageConverters = new ArrayList<>(originalMessageConverters); springConnectorWebMvc.extendMessageConverters(adjustedMessageConverters); assertThat(originalMessageConverters.size()).isEqualTo(3); assertThat(adjustedMessageConverters.size()).isEqualTo(3); assertThat(originalMessageConverters.get(0)).isEqualTo(adjustedMessageConverters.get(0)); assertThat(originalMessageConverters.get(1)).isNotEqualTo(adjustedMessageConverters.get(1)); assertThat(originalMessageConverters.get(2)).isEqualTo(adjustedMessageConverters.get(2)); }
@Test public void testExtendMessageConvertersWithMultipleTypesOfHttpConverter() { final List<HttpMessageConverter<?>> originalMessageConverters = configureInitialMessageConvertersWithProblems(); final List<HttpMessageConverter<?>> adjustedMessageConverters = new ArrayList<>(originalMessageConverters); springConnectorWebMvc.extendMessageConverters(adjustedMessageConverters); assertThat(originalMessageConverters.size()).isEqualTo(4); assertThat(adjustedMessageConverters.size()).isEqualTo(4); assertThat(originalMessageConverters.get(0)).isEqualTo(adjustedMessageConverters.get(0)); assertThat(originalMessageConverters.get(1)).isEqualTo(adjustedMessageConverters.get(1)); assertThat(originalMessageConverters.get(2)).isNotEqualTo(adjustedMessageConverters.get(2)); assertThat(originalMessageConverters.get(3)).isEqualTo(adjustedMessageConverters.get(3)); } |
PeerProtocolPacketFilter extends AbstractPacketFilter implements PacketSwitchFilter { @Override public InterledgerResponsePacket doFilter( final AccountSettings sourceAccountSettings, final InterledgerPreparePacket sourcePreparePacket, final PacketSwitchFilterChain filterChain ) { if (sourcePreparePacket.getDestination().startsWith(InterledgerAddress.AllocationScheme.PEER.getValue())) { if (sourcePreparePacket.getDestination().equals(IldcpRequestPacket.PEER_DOT_CONFIG)) { if (connectorSettingsSupplier.get().enabledProtocols().isIldcpEnabled()) { return this.handleIldcpRequest(sourceAccountSettings, sourcePreparePacket); } else { return packetRejector.reject( LinkId.of(sourceAccountSettings.accountId().value()), sourcePreparePacket, InterledgerErrorCode.F00_BAD_REQUEST, "IL-DCP is not supported by this Connector."); } } else if (sourcePreparePacket.getDestination().startsWith(PEER_DOT_ROUTE)) { if (connectorSettingsSupplier.get().enabledProtocols().isPeerRoutingEnabled()) { return handlePeerRouting(sourceAccountSettings, sourcePreparePacket); } else { return packetRejector.reject( LinkId.of(sourceAccountSettings.accountId().value()), sourcePreparePacket, InterledgerErrorCode.F00_BAD_REQUEST, "CCP routing protocol is not supported by this node."); } } else if (sourcePreparePacket.getDestination().startsWith(PEER_DOT_SETTLE)) { return handlePeerSettlement(sourceAccountSettings, sourcePreparePacket); } else { return packetRejector.reject( LinkId.of(sourceAccountSettings.accountId().value()), sourcePreparePacket, InterledgerErrorCode.F01_INVALID_PACKET, "unknown peer protocol." ); } } else { return filterChain.doFilter(sourceAccountSettings, sourcePreparePacket); } } PeerProtocolPacketFilter(
final Supplier<ConnectorSettings> connectorSettingsSupplier,
final PacketRejector packetRejector,
final RouteBroadcaster routeBroadcaster,
final CodecContext ccpCodecContext,
final CodecContext ildcpCodecContext,
final SettlementService settlementService
); @Override InterledgerResponsePacket doFilter(
final AccountSettings sourceAccountSettings,
final InterledgerPreparePacket sourcePreparePacket,
final PacketSwitchFilterChain filterChain
); } | @Test public void doFilterForPeerDotConfigWhenDisabled() { when(enabledProtocolSettingsMock.isIldcpEnabled()).thenReturn(false); final InterledgerPreparePacket preparePacket = this.constructPreparePacket(IldcpRequestPacket.PEER_DOT_CONFIG); filter.doFilter(accountSettingsMock, preparePacket, filterChainMock).handle( fulfillPacket -> fail(String.format("Should not fulfill: %s", fulfillPacket)), rejectPacket -> { final ArgumentCaptor<InterledgerErrorCode> errorCodeArgumentCaptor = ArgumentCaptor.forClass(InterledgerErrorCode.class); final ArgumentCaptor<String> errorMessageCaptor = ArgumentCaptor.forClass(String.class); verify(packetRejectorMock) .reject(any(), any(), errorCodeArgumentCaptor.capture(), errorMessageCaptor.capture()); assertThat(errorCodeArgumentCaptor.getValue()).isEqualTo(InterledgerErrorCode.F00_BAD_REQUEST); assertThat(errorMessageCaptor.getValue()).isEqualTo("IL-DCP is not supported by this Connector."); } ); }
@Test public void doFilterForPeerDotConfigWithVariousSettings() { when(enabledProtocolSettingsMock.isIldcpEnabled()).thenReturn(true); final InterledgerPreparePacket preparePacket = this.constructPreparePacket(IldcpRequestPacket.PEER_DOT_CONFIG); filter.doFilter(accountSettingsMock, preparePacket, filterChainMock) .handle( fulfillPacket -> assertThat(fulfillPacket.getFulfillment()).isEqualTo(IldcpResponsePacket.EXECUTION_FULFILLMENT), rejectPacket -> fail(String.format("Should not reject: %s", rejectPacket)) ); }
@Test public void doFilterForPeerDotRouteWhenDisabled() { when(enabledProtocolSettingsMock.isPeerRoutingEnabled()).thenReturn(false); final InterledgerPreparePacket preparePacket = this.constructPreparePacket(InterledgerAddress.of("peer.route")); filter.doFilter(accountSettingsMock, preparePacket, filterChainMock).handle( fulfillPacket -> fail(String.format("Should not fulfill: %s", fulfillPacket)), rejectPacket -> { final ArgumentCaptor<InterledgerErrorCode> errorCodeArgumentCaptor = ArgumentCaptor.forClass(InterledgerErrorCode.class); final ArgumentCaptor<String> errorMessageCaptor = ArgumentCaptor.forClass(String.class); verify(packetRejectorMock) .reject(any(), any(), errorCodeArgumentCaptor.capture(), errorMessageCaptor.capture()); assertThat(errorCodeArgumentCaptor.getValue()).isEqualTo(InterledgerErrorCode.F00_BAD_REQUEST); assertThat(errorMessageCaptor.getValue()).isEqualTo("CCP routing protocol is not supported by this node."); } ); }
@Test public void doFilterForPeerDotRouteDotControl() throws IOException { when(enabledProtocolSettingsMock.isPeerRoutingEnabled()).thenReturn(true); final CcpRouteControlRequest routeControlRequest = CcpRouteControlRequest.builder() .lastKnownEpoch(1) .lastKnownRoutingTableId(RoutingTableId.of(UUID.randomUUID())) .mode(CcpSyncMode.MODE_IDLE) .build(); final ByteArrayOutputStream os = new ByteArrayOutputStream(); CcpCodecContextFactory.oer().write(routeControlRequest, os); final InterledgerPreparePacket preparePacket = InterledgerPreparePacket.builder() .destination(CCP_CONTROL_DESTINATION_ADDRESS) .executionCondition(PEER_PROTOCOL_EXECUTION_CONDITION) .amount(UnsignedLong.valueOf(10)) .expiresAt(Instant.now().plusSeconds(30)) .data(os.toByteArray()) .build(); filter.doFilter(accountSettingsMock, preparePacket, filterChainMock).handle( fulfillPacket -> { if (!sendRoutesEnabled) { fail(String.format("Should not have fulfilled when sendRoutes is disabled! %s", fulfillPacket)); } else { assertThat(fulfillPacket.getFulfillment()).as("Should have fulfilled when sendRoutes is enabled").isEqualTo(PEER_PROTOCOL_EXECUTION_FULFILLMENT); } }, rejectPacket -> { if (!sendRoutesEnabled) { final ArgumentCaptor<InterledgerErrorCode> errorCodeArgumentCaptor = ArgumentCaptor.forClass(InterledgerErrorCode.class); final ArgumentCaptor<String> errorMessageCaptor = ArgumentCaptor.forClass(String.class); verify(packetRejectorMock) .reject(any(), any(), errorCodeArgumentCaptor.capture(), errorMessageCaptor.capture()); assertThat(errorCodeArgumentCaptor.getValue()).isEqualTo(InterledgerErrorCode.F00_BAD_REQUEST); assertThat(errorMessageCaptor.getValue()).isEqualTo("CCP sending is not enabled for this account. destinationAddress=peer.route.control"); assertThat(rejectPacket.getCode()).isEqualTo(InterledgerErrorCode.F00_BAD_REQUEST); assertThat(rejectPacket.getTriggeredBy().get()).isEqualTo(OPERATOR_ADDRESS); } else { fail(String.format("Should not have rejected when sendRoutes is enabled. %s", rejectPacket)); } } ); }
@Test public void doFilterForPeerDotRouteDotUpdate() throws IOException { when(enabledProtocolSettingsMock.isPeerRoutingEnabled()).thenReturn(true); final CcpRouteUpdateRequest routeControlRequest = CcpRouteUpdateRequest.builder() .currentEpochIndex(0) .fromEpochIndex(0) .toEpochIndex(1) .holdDownTime(9L) .routingTableId(RoutingTableId.of(UUID.randomUUID())) .speaker(OPERATOR_ADDRESS) .build(); final ByteArrayOutputStream os = new ByteArrayOutputStream(); CcpCodecContextFactory.oer().write(routeControlRequest, os); final InterledgerPreparePacket preparePacket = InterledgerPreparePacket.builder() .destination(CCP_UPDATE_DESTINATION_ADDRESS) .executionCondition(PEER_PROTOCOL_EXECUTION_CONDITION) .amount(UnsignedLong.valueOf(10)) .expiresAt(Instant.now().plusSeconds(30)) .data(os.toByteArray()) .build(); filter.doFilter(accountSettingsMock, preparePacket, filterChainMock).handle( fulfillPacket -> { if (!receiveRoutesEnabled) { fail(String.format("Should not have fulfilled when sendRoutes is disabled! %s", fulfillPacket)); } else { assertThat(fulfillPacket.getFulfillment()).as("Should have fulfilled when receiveRoutes is enabled").isEqualTo(PEER_PROTOCOL_EXECUTION_FULFILLMENT); } }, rejectPacket -> { if (!receiveRoutesEnabled) { final ArgumentCaptor<InterledgerErrorCode> errorCodeArgumentCaptor = ArgumentCaptor.forClass(InterledgerErrorCode.class); final ArgumentCaptor<String> errorMessageCaptor = ArgumentCaptor.forClass(String.class); verify(packetRejectorMock) .reject(any(), any(), errorCodeArgumentCaptor.capture(), errorMessageCaptor.capture()); assertThat(errorCodeArgumentCaptor.getValue()).isEqualTo(InterledgerErrorCode.F00_BAD_REQUEST); assertThat(errorMessageCaptor.getValue()).isEqualTo("CCP receiving is not enabled for this account. destinationAddress=peer.route.update"); assertThat(rejectPacket.getCode()).isEqualTo(InterledgerErrorCode.F00_BAD_REQUEST); assertThat(rejectPacket.getTriggeredBy().get()).isEqualTo(OPERATOR_ADDRESS); } else { fail(String.format("Should not have rejected when receiveRoutes is enabled! %s", rejectPacket)); } } ); }
@Test public void doFilterForPeerDotFoo() { final InterledgerPreparePacket preparePacket = this.constructPreparePacket(InterledgerAddress.of("peer.foo")); filter.doFilter(accountSettingsMock, preparePacket, filterChainMock).handle( fulfillPacket -> fail(String.format("Should not fulfill: %s", fulfillPacket)), rejectPacket -> { final ArgumentCaptor<InterledgerErrorCode> errorCodeArgumentCaptor = ArgumentCaptor.forClass(InterledgerErrorCode.class); final ArgumentCaptor<String> errorMessageCaptor = ArgumentCaptor.forClass(String.class); verify(packetRejectorMock) .reject(any(), any(), errorCodeArgumentCaptor.capture(), errorMessageCaptor.capture()); assertThat(errorCodeArgumentCaptor.getValue()).isEqualTo(InterledgerErrorCode.F01_INVALID_PACKET); assertThat(errorMessageCaptor.getValue()).isEqualTo("unknown peer protocol."); } ); } |
DefaultPacketSwitchFilterChain implements PacketSwitchFilterChain { @Override public InterledgerResponsePacket doFilter( final AccountSettings sourceAccountSettings, final InterledgerPreparePacket preparePacket ) { Objects.requireNonNull(sourceAccountSettings); Objects.requireNonNull(preparePacket); try { if (this._filterIndex < this.packetSwitchFilters.size()) { return packetSwitchFilters.get(_filterIndex++).doFilter(sourceAccountSettings, preparePacket, this); } else { logger.debug( "Sending outbound ILP Prepare: sourceAccountId: `{}` packet={}", sourceAccountSettings.accountId(), preparePacket ); final NextHopInfo nextHopInfo = this.nextHopPacketMapper.getNextHopPacket( sourceAccountSettings, preparePacket ); final AccountSettings nextHopAccountSettings = accountSettingsLoadingCache .getAccount(nextHopInfo.nextHopAccountId()) .orElseThrow(() -> new AccountNotFoundProblem(nextHopInfo.nextHopAccountId())); final Link<? extends LinkSettings> link = computeLink(nextHopAccountSettings, preparePacket.getDestination()); InterledgerResponsePacket response = new DefaultLinkFilterChain(packetRejector, linkFilters, link) .doFilter(nextHopAccountSettings, nextHopInfo.nextHopPacket()); this.trackPacket(sourceAccountSettings, preparePacket, nextHopInfo, nextHopAccountSettings, response); return response; } } catch (Exception e) { logger.error("Failure in PacketSwitchFilterChain: " + e.getMessage(), e); if (InterledgerRuntimeException.class.isAssignableFrom(e.getClass())) { return ((InterledgerProtocolException) e).getInterledgerRejectPacket(); } else { return packetRejector.reject( LinkId.of(sourceAccountSettings.accountId().value()), preparePacket, InterledgerErrorCode.T00_INTERNAL_ERROR, e.getMessage() ); } } } DefaultPacketSwitchFilterChain(
final PacketRejector packetRejector,
final List<PacketSwitchFilter> packetSwitchFilters,
final List<LinkFilter> linkFilters,
final LocalDestinationAddressUtils localDestinationAddressUtils,
final LinkManager linkManager,
final NextHopPacketMapper nextHopPacketMapper,
final AccountSettingsLoadingCache accountSettingsLoadingCache,
final PacketEventPublisher packetEventPublisher
); @Override InterledgerResponsePacket doFilter(
final AccountSettings sourceAccountSettings, final InterledgerPreparePacket preparePacket
); } | @Test public void filterPacketWithNoFilters() { assertThat(this.packetSwitchFilters.size()).isEqualTo(0); final NextHopInfo nextHopInfo = NextHopInfo.builder() .nextHopAccountId(OUTGOING_ACCOUNT_ID) .nextHopPacket(PREPARE_PACKET) .build(); when(nextHopPacketMapperMock.getNextHopPacket(eq(INCOMING_ACCOUNT_SETTINGS), eq(PREPARE_PACKET))) .thenReturn(nextHopInfo); when(linkManagerMock.getOrCreateLink(OUTGOING_ACCOUNT_ID)).thenReturn(outgoingLink); when(nextHopPacketMapperMock.determineExchangeRate(any(), any(), any())).thenReturn(BigDecimal.ZERO); final Link linkMock = mock(Link.class); when(linkManagerMock.getOrCreateLink(OUTGOING_ACCOUNT_SETTINGS)).thenReturn(linkMock); when(linkMock.sendPacket(any())) .thenReturn(InterledgerFulfillPacket.builder().fulfillment(LoopbackLink.LOOPBACK_FULFILLMENT).build()); filterChain.doFilter(INCOMING_ACCOUNT_SETTINGS, PREPARE_PACKET).handle( fulfillPacket -> assertThat(fulfillPacket.getFulfillment()).isEqualTo(LoopbackLink.LOOPBACK_FULFILLMENT), rejectPacket -> fail("Should have fulfilled but rejected!") ); verify(linkFiltersMock).size(); verify(linkManagerMock).getOrCreateLink(OUTGOING_ACCOUNT_SETTINGS); verify(nextHopPacketMapperMock).getNextHopPacket(INCOMING_ACCOUNT_SETTINGS, PREPARE_PACKET); verify(nextHopPacketMapperMock).determineExchangeRate(any(), any(), any()); assertThat(this.packetSwitchFilters.size()).isEqualTo(0); verifyNoMoreInteractions(nextHopPacketMapperMock); verifyNoMoreInteractions(linkFiltersMock); }
@Test public void filterPacketWithMultipleFilters() { final PacketSwitchFilter packetSwitchFilter1 = (sourceAccountSettings, sourcePreparePacket, filterChain) -> filterChain .doFilter(sourceAccountSettings, sourcePreparePacket); this.packetSwitchFilters.add(packetSwitchFilter1); final PacketSwitchFilter packetSwitchFilter2 = (sourceAccountSettings, sourcePreparePacket, filterChain) -> filterChain.doFilter(sourceAccountSettings, sourcePreparePacket); this.packetSwitchFilters.add(packetSwitchFilter2); assertThat(this.packetSwitchFilters.size()).isEqualTo(2); final NextHopInfo nextHopInfo = NextHopInfo.builder() .nextHopAccountId(OUTGOING_ACCOUNT_ID) .nextHopPacket(PREPARE_PACKET) .build(); when(nextHopPacketMapperMock.getNextHopPacket(INCOMING_ACCOUNT_SETTINGS, PREPARE_PACKET)).thenReturn(nextHopInfo); when(linkManagerMock.getOrCreateLink(Mockito.<AccountSettings>any())).thenReturn(outgoingLink); when(nextHopPacketMapperMock.determineExchangeRate(any(), any(), any())).thenReturn(BigDecimal.ZERO); filterChain.doFilter(INCOMING_ACCOUNT_SETTINGS, PREPARE_PACKET).handle( fulfillPacket -> assertThat(fulfillPacket.getFulfillment()).isEqualTo(LoopbackLink.LOOPBACK_FULFILLMENT), rejectPacket -> fail("Should have fulfilled but rejected!") ); verify(linkFiltersMock).size(); verify(linkManagerMock).getOrCreateLink(OUTGOING_ACCOUNT_SETTINGS); verify(nextHopPacketMapperMock).getNextHopPacket(INCOMING_ACCOUNT_SETTINGS, PREPARE_PACKET); verify(nextHopPacketMapperMock).determineExchangeRate(any(), any(), any()); verifyNoMoreInteractions(nextHopPacketMapperMock); verifyNoMoreInteractions(linkFiltersMock); }
@Test public void filterPacketWithExceptionInFirstFilter() { final PacketSwitchFilter packetSwitchFilter1 = (sourceAccountSettings, sourcePreparePacket, filterChain) -> { packetSwitchFilter1PreProcessed.set(true); throw new RuntimeException("Simulated PacketSwitchFilter exception"); }; this.packetSwitchFilters.add(packetSwitchFilter1); final PacketSwitchFilter packetSwitchFilter2 = (sourceAccountSettings, sourcePreparePacket, filterChain) -> { packetSwitchFilter2PreProcessed.set(true); InterledgerResponsePacket responsePacket = filterChain.doFilter(sourceAccountSettings, sourcePreparePacket); packetSwitchFilter2PostProcessed.set(true); return responsePacket; }; this.packetSwitchFilters.add(packetSwitchFilter2); final PacketSwitchFilter packetSwitchFilter3 = (sourceAccountSettings, sourcePreparePacket, filterChain) -> { packetSwitchFilter3PreProcessed.set(true); InterledgerResponsePacket responsePacket = filterChain.doFilter(sourceAccountSettings, sourcePreparePacket); packetSwitchFilter3PostProcessed.set(true); return responsePacket; }; this.packetSwitchFilters.add(packetSwitchFilter3); assertThat(this.packetSwitchFilters.size()).isEqualTo(3); final NextHopInfo nextHopInfo = NextHopInfo.builder() .nextHopAccountId(OUTGOING_ACCOUNT_ID) .nextHopPacket(PREPARE_PACKET) .build(); when(nextHopPacketMapperMock.getNextHopPacket(INCOMING_ACCOUNT_SETTINGS, PREPARE_PACKET)).thenReturn(nextHopInfo); when(linkManagerMock.getOrCreateLink(Mockito.<AccountSettings>any())).thenReturn(outgoingLink); when(nextHopPacketMapperMock.determineExchangeRate(any(), any(), any())).thenReturn(BigDecimal.ZERO); filterChain.doFilter(INCOMING_ACCOUNT_SETTINGS, PREPARE_PACKET).handle( fulfillPacket -> fail("Should have rejected but fulfilled!"), rejectPacket -> assertThat(rejectPacket.getCode()).isEqualTo(InterledgerErrorCode.T00_INTERNAL_ERROR) ); assertThat(packetSwitchFilter1PreProcessed).isTrue(); assertThat(packetSwitchFilter1PostProcessed).isFalse(); assertThat(packetSwitchFilter2PreProcessed).isFalse(); assertThat(packetSwitchFilter2PostProcessed).isFalse(); assertThat(packetSwitchFilter3PreProcessed).isFalse(); assertThat(packetSwitchFilter3PostProcessed).isFalse(); verifyNoInteractions(nextHopPacketMapperMock); verifyNoInteractions(linkFiltersMock); verifyNoInteractions(accountSettingsLoadingCacheMock); verifyNoInteractions(packetEventPublisherMock); }
@Test public void filterPacketWithExceptionInMiddleFilter() { final PacketSwitchFilter packetSwitchFilter1 = (sourceAccountSettings, sourcePreparePacket, filterChain) -> { packetSwitchFilter1PreProcessed.set(true); InterledgerResponsePacket responsePacket = filterChain.doFilter(sourceAccountSettings, sourcePreparePacket); packetSwitchFilter1PostProcessed.set(true); return responsePacket; }; this.packetSwitchFilters.add(packetSwitchFilter1); final PacketSwitchFilter packetSwitchFilter2 = (sourceAccountSettings, sourcePreparePacket, filterChain) -> { packetSwitchFilter2PreProcessed.set(true); throw new RuntimeException("Simulated PacketSwitchFilter exception"); }; this.packetSwitchFilters.add(packetSwitchFilter2); final PacketSwitchFilter packetSwitchFilter3 = (sourceAccountSettings, sourcePreparePacket, filterChain) -> { packetSwitchFilter3PreProcessed.set(true); InterledgerResponsePacket responsePacket = filterChain.doFilter(sourceAccountSettings, sourcePreparePacket); packetSwitchFilter3PostProcessed.set(true); return responsePacket; }; this.packetSwitchFilters.add(packetSwitchFilter3); assertThat(this.packetSwitchFilters.size()).isEqualTo(3); final NextHopInfo nextHopInfo = NextHopInfo.builder() .nextHopAccountId(OUTGOING_ACCOUNT_ID) .nextHopPacket(PREPARE_PACKET) .build(); when(nextHopPacketMapperMock.getNextHopPacket(INCOMING_ACCOUNT_SETTINGS, PREPARE_PACKET)).thenReturn(nextHopInfo); when(linkManagerMock.getOrCreateLink(Mockito.<AccountSettings>any())).thenReturn(outgoingLink); when(nextHopPacketMapperMock.determineExchangeRate(any(), any(), any())).thenReturn(BigDecimal.ZERO); filterChain.doFilter(INCOMING_ACCOUNT_SETTINGS, PREPARE_PACKET).handle( fulfillPacket -> fail("Should have rejected but fulfilled!"), rejectPacket -> assertThat(rejectPacket.getCode()).isEqualTo(InterledgerErrorCode.T00_INTERNAL_ERROR) ); assertThat(packetSwitchFilter1PreProcessed).isTrue(); assertThat(packetSwitchFilter1PostProcessed).isTrue(); assertThat(packetSwitchFilter2PreProcessed).isTrue(); assertThat(packetSwitchFilter2PostProcessed).isFalse(); assertThat(packetSwitchFilter3PreProcessed).isFalse(); assertThat(packetSwitchFilter3PostProcessed).isFalse(); verifyNoInteractions(nextHopPacketMapperMock); verifyNoInteractions(linkFiltersMock); verifyNoInteractions(accountSettingsLoadingCacheMock); verifyNoInteractions(packetEventPublisherMock); }
@Test public void filterPacketWithExceptionInLastFilter() { final PacketSwitchFilter packetSwitchFilter1 = (sourceAccountSettings, sourcePreparePacket, filterChain) -> { packetSwitchFilter1PreProcessed.set(true); InterledgerResponsePacket responsePacket = filterChain.doFilter(sourceAccountSettings, sourcePreparePacket); packetSwitchFilter1PostProcessed.set(true); return responsePacket; }; this.packetSwitchFilters.add(packetSwitchFilter1); final PacketSwitchFilter packetSwitchFilter2 = (sourceAccountSettings, sourcePreparePacket, filterChain) -> { packetSwitchFilter2PreProcessed.set(true); InterledgerResponsePacket responsePacket = filterChain.doFilter(sourceAccountSettings, sourcePreparePacket); packetSwitchFilter2PostProcessed.set(true); return responsePacket; }; this.packetSwitchFilters.add(packetSwitchFilter2); final PacketSwitchFilter packetSwitchFilter3 = (sourceAccountSettings, sourcePreparePacket, filterChain) -> { packetSwitchFilter3PreProcessed.set(true); throw new RuntimeException("Simulated PacketSwitchFilter exception"); }; this.packetSwitchFilters.add(packetSwitchFilter3); assertThat(this.packetSwitchFilters.size()).isEqualTo(3); final NextHopInfo nextHopInfo = NextHopInfo.builder() .nextHopAccountId(OUTGOING_ACCOUNT_ID) .nextHopPacket(PREPARE_PACKET) .build(); when(nextHopPacketMapperMock.getNextHopPacket(INCOMING_ACCOUNT_SETTINGS, PREPARE_PACKET)).thenReturn(nextHopInfo); when(linkManagerMock.getOrCreateLink(Mockito.<AccountSettings>any())).thenReturn(outgoingLink); when(nextHopPacketMapperMock.determineExchangeRate(any(), any(), any())).thenReturn(BigDecimal.ZERO); filterChain.doFilter(INCOMING_ACCOUNT_SETTINGS, PREPARE_PACKET).handle( fulfillPacket -> fail("Should have rejected but fulfilled!"), rejectPacket -> assertThat(rejectPacket.getCode()).isEqualTo(InterledgerErrorCode.T00_INTERNAL_ERROR) ); assertThat(packetSwitchFilter1PreProcessed).isTrue(); assertThat(packetSwitchFilter1PostProcessed).isTrue(); assertThat(packetSwitchFilter2PreProcessed).isTrue(); assertThat(packetSwitchFilter2PostProcessed).isTrue(); assertThat(packetSwitchFilter3PreProcessed).isTrue(); assertThat(packetSwitchFilter3PostProcessed).isFalse(); verifyNoInteractions(nextHopPacketMapperMock); verifyNoInteractions(linkFiltersMock); verifyNoInteractions(accountSettingsLoadingCacheMock); verifyNoInteractions(packetEventPublisherMock); }
@Test public void filterPacketWithExpiredPacket() { final PacketSwitchFilter packetSwitchFilter1 = (sourceAccountSettings, sourcePreparePacket, filterChain) -> { packetSwitchFilter1PreProcessed.set(true); InterledgerResponsePacket responsePacket = filterChain.doFilter(sourceAccountSettings, sourcePreparePacket); packetSwitchFilter1PostProcessed.set(true); return responsePacket; }; this.packetSwitchFilters.add(packetSwitchFilter1); final PacketSwitchFilter packetSwitchFilter2 = (sourceAccountSettings, sourcePreparePacket, filterChain) -> { packetSwitchFilter2PreProcessed.set(true); InterledgerResponsePacket responsePacket = filterChain.doFilter(sourceAccountSettings, sourcePreparePacket); packetSwitchFilter2PostProcessed.set(true); return responsePacket; }; this.packetSwitchFilters.add(packetSwitchFilter2); final PacketSwitchFilter packetSwitchFilter3 = (sourceAccountSettings, sourcePreparePacket, filterChain) -> { packetSwitchFilter3PreProcessed.set(true); InterledgerResponsePacket responsePacket = filterChain.doFilter(sourceAccountSettings, sourcePreparePacket); packetSwitchFilter3PostProcessed.set(true); return responsePacket; }; this.packetSwitchFilters.add(packetSwitchFilter3); assertThat(this.packetSwitchFilters.size()).isEqualTo(3); when(nextHopPacketMapperMock.getNextHopPacket(INCOMING_ACCOUNT_SETTINGS, PREPARE_PACKET)) .thenThrow(new RuntimeException("Simulated Exception")); when(linkManagerMock.getOrCreateLink(Mockito.<AccountSettings>any())).thenReturn(outgoingLink); when(nextHopPacketMapperMock.determineExchangeRate(any(), any(), any())).thenReturn(BigDecimal.ZERO); filterChain.doFilter(INCOMING_ACCOUNT_SETTINGS, PREPARE_PACKET).handle( fulfillPacket -> fail("Should have rejected but fulfilled!"), rejectPacket -> assertThat(rejectPacket.getCode()).isEqualTo(InterledgerErrorCode.T00_INTERNAL_ERROR) ); assertThat(packetSwitchFilter1PreProcessed).isTrue(); assertThat(packetSwitchFilter1PostProcessed).isTrue(); assertThat(packetSwitchFilter2PreProcessed).isTrue(); assertThat(packetSwitchFilter2PostProcessed).isTrue(); assertThat(packetSwitchFilter3PreProcessed).isTrue(); assertThat(packetSwitchFilter3PostProcessed).isTrue(); verify(nextHopPacketMapperMock).getNextHopPacket(INCOMING_ACCOUNT_SETTINGS, PREPARE_PACKET); verifyNoMoreInteractions(nextHopPacketMapperMock); verifyNoInteractions(linkFiltersMock); verifyNoInteractions(accountSettingsLoadingCacheMock); verifyNoInteractions(packetEventPublisherMock); }
@Test public void filterPacketWithInvalidFx() { final PacketSwitchFilter packetSwitchFilter1 = (sourceAccountSettings, sourcePreparePacket, filterChain) -> { packetSwitchFilter1PreProcessed.set(true); InterledgerResponsePacket responsePacket = filterChain.doFilter(sourceAccountSettings, sourcePreparePacket); packetSwitchFilter1PostProcessed.set(true); return responsePacket; }; this.packetSwitchFilters.add(packetSwitchFilter1); final PacketSwitchFilter packetSwitchFilter2 = (sourceAccountSettings, sourcePreparePacket, filterChain) -> { packetSwitchFilter2PreProcessed.set(true); InterledgerResponsePacket responsePacket = filterChain.doFilter(sourceAccountSettings, sourcePreparePacket); packetSwitchFilter2PostProcessed.set(true); return responsePacket; }; this.packetSwitchFilters.add(packetSwitchFilter2); final PacketSwitchFilter packetSwitchFilter3 = (sourceAccountSettings, sourcePreparePacket, filterChain) -> { packetSwitchFilter3PreProcessed.set(true); InterledgerResponsePacket responsePacket = filterChain.doFilter(sourceAccountSettings, sourcePreparePacket); packetSwitchFilter3PostProcessed.set(true); return responsePacket; }; this.packetSwitchFilters.add(packetSwitchFilter3); assertThat(this.packetSwitchFilters.size()).isEqualTo(3); final NextHopInfo nextHopInfo = NextHopInfo.builder() .nextHopAccountId(PING_ACCOUNT_ID) .nextHopPacket(PREPARE_PACKET) .build(); when(nextHopPacketMapperMock.getNextHopPacket(eq(INCOMING_ACCOUNT_SETTINGS), eq(PREPARE_PACKET))) .thenReturn(nextHopInfo); when(linkManagerMock.getOrCreateLink(Mockito.<AccountSettings>any())) .thenThrow(new RuntimeException("Simulated Link Exception")); when(nextHopPacketMapperMock.determineExchangeRate(any(), any(), any())).thenReturn(BigDecimal.ZERO); filterChain.doFilter(INCOMING_ACCOUNT_SETTINGS, PREPARE_PACKET).handle( fulfillPacket -> fail("Should have rejected but fulfilled!"), rejectPacket -> assertThat(rejectPacket.getCode()).isEqualTo(InterledgerErrorCode.T00_INTERNAL_ERROR) ); assertThat(packetSwitchFilter1PreProcessed).isTrue(); assertThat(packetSwitchFilter1PostProcessed).isTrue(); assertThat(packetSwitchFilter2PreProcessed).isTrue(); assertThat(packetSwitchFilter2PostProcessed).isTrue(); assertThat(packetSwitchFilter3PreProcessed).isTrue(); assertThat(packetSwitchFilter3PostProcessed).isTrue(); verify(nextHopPacketMapperMock).getNextHopPacket(INCOMING_ACCOUNT_SETTINGS, PREPARE_PACKET); verify(accountSettingsLoadingCacheMock).getAccount(any()); verifyNoMoreInteractions(nextHopPacketMapperMock); verifyNoMoreInteractions(accountSettingsLoadingCacheMock); verifyNoInteractions(linkFiltersMock); verifyNoInteractions(packetEventPublisherMock); }
@Test public void filterPacketForPingLink() { assertThat(this.packetSwitchFilters.size()).isEqualTo(0); final InterledgerPreparePacket pingPreparePacket = InterledgerPreparePacket.builder() .destination(OPERATOR_ADDRESS) .amount(UnsignedLong.ONE) .expiresAt(Instant.now().plusSeconds(30)) .executionCondition(PING_PROTOCOL_CONDITION) .build(); this.outgoingLink = new PingLoopbackLink( () -> OPERATOR_ADDRESS, OUTGOING_LINK_SETTINGS ); final NextHopInfo nextHopInfo = NextHopInfo.builder() .nextHopAccountId(PING_ACCOUNT_ID) .nextHopPacket(pingPreparePacket) .build(); when(nextHopPacketMapperMock.getNextHopPacket(eq(INCOMING_ACCOUNT_SETTINGS), eq(pingPreparePacket))) .thenReturn(nextHopInfo); when(nextHopPacketMapperMock.determineExchangeRate(any(), any(), any())).thenReturn(BigDecimal.ZERO); when(localDestinationAddressUtilsMock.isLocalDestinationAddress(OPERATOR_ADDRESS)).thenReturn(true); final Link pingLink = mock(Link.class); when(linkManagerMock.getOrCreateLink(Mockito.<AccountSettings>any())).thenReturn(pingLink); when(pingLink.sendPacket(pingPreparePacket)) .thenReturn(InterledgerFulfillPacket.builder().fulfillment(PingLoopbackLink.PING_PROTOCOL_FULFILLMENT).build()); filterChain.doFilter(INCOMING_ACCOUNT_SETTINGS, pingPreparePacket).handle( fulfillPacket -> assertThat(fulfillPacket.getFulfillment()).isEqualTo(PingLoopbackLink.PING_PROTOCOL_FULFILLMENT), rejectPacket -> fail("Should have fulfilled but rejected!") ); verify(linkFiltersMock).size(); verify(nextHopPacketMapperMock).getNextHopPacket(INCOMING_ACCOUNT_SETTINGS, pingPreparePacket); verify(nextHopPacketMapperMock).determineExchangeRate(any(), any(), any()); assertThat(this.packetSwitchFilters.size()).isEqualTo(0); verifyNoMoreInteractions(nextHopPacketMapperMock); verifyNoMoreInteractions(linkFiltersMock); }
@Test public void testDoFilterWithLocalSpspAddress() { final InterledgerPreparePacket pingPreparePacket = InterledgerPreparePacket.builder() .destination(OPERATOR_ADDRESS) .amount(UnsignedLong.ONE) .expiresAt(Instant.now().plusSeconds(30)) .executionCondition(PING_PROTOCOL_CONDITION) .build(); this.outgoingLink = new PingLoopbackLink( () -> OPERATOR_ADDRESS, OUTGOING_LINK_SETTINGS ); when(nextHopPacketMapperMock.getNextHopPacket(eq(INCOMING_ACCOUNT_SETTINGS), eq(pingPreparePacket))) .thenReturn( NextHopInfo.builder() .nextHopAccountId(OUTGOING_ACCOUNT_ID) .nextHopPacket(pingPreparePacket) .build() ); when(nextHopPacketMapperMock.determineExchangeRate(any(), any(), any())).thenReturn(BigDecimal.ZERO); when(localDestinationAddressUtilsMock.isLocalSpspDestinationAddress(any())).thenReturn(true); when(linkManagerMock.getOrCreateSpspReceiverLink(any())).thenReturn(outgoingLink); filterChain.doFilter(INCOMING_ACCOUNT_SETTINGS, pingPreparePacket).handle( fulfillPacket -> assertThat(fulfillPacket.getFulfillment()).isEqualTo(PingLoopbackLink.PING_PROTOCOL_FULFILLMENT), rejectPacket -> fail("Should have fulfilled but rejected!") ); verify(localDestinationAddressUtilsMock).isLocalSpspDestinationAddress(OPERATOR_ADDRESS); verifyNoMoreInteractions(localDestinationAddressUtilsMock); verify(linkManagerMock).getOrCreateSpspReceiverLink(OUTGOING_ACCOUNT_SETTINGS); verifyNoMoreInteractions(linkManagerMock); }
@Test public void testDoFilterWithNonLocalSpspAddress() { final InterledgerAddress destinationAddres = InterledgerAddress.of("example.foo.bar.baz"); final InterledgerPreparePacket pingPreparePacket = InterledgerPreparePacket.builder() .destination(destinationAddres) .amount(UnsignedLong.ONE) .expiresAt(Instant.now().plusSeconds(30)) .executionCondition(PING_PROTOCOL_CONDITION) .build(); this.outgoingLink = new PingLoopbackLink( () -> OPERATOR_ADDRESS, OUTGOING_LINK_SETTINGS ); when(nextHopPacketMapperMock.getNextHopPacket(eq(INCOMING_ACCOUNT_SETTINGS), eq(pingPreparePacket))) .thenReturn( NextHopInfo.builder() .nextHopAccountId(OUTGOING_ACCOUNT_ID) .nextHopPacket(pingPreparePacket) .build() ); when(nextHopPacketMapperMock.determineExchangeRate(any(), any(), any())).thenReturn(BigDecimal.ZERO); when(localDestinationAddressUtilsMock.isLocalSpspDestinationAddress(any())).thenReturn(false); when(linkManagerMock.getOrCreateLink(Mockito.<AccountSettings>any())).thenReturn(outgoingLink); filterChain.doFilter(INCOMING_ACCOUNT_SETTINGS, pingPreparePacket).handle( fulfillPacket -> assertThat(fulfillPacket.getFulfillment()).isEqualTo(PingLoopbackLink.PING_PROTOCOL_FULFILLMENT), rejectPacket -> fail("Should have fulfilled but rejected!") ); verify(localDestinationAddressUtilsMock).isLocalSpspDestinationAddress(destinationAddres); verifyNoMoreInteractions(localDestinationAddressUtilsMock); verify(linkManagerMock).getOrCreateLink(OUTGOING_ACCOUNT_SETTINGS); verifyNoMoreInteractions(linkManagerMock); } |
DefaultPacketSwitchFilterChain implements PacketSwitchFilterChain { @VisibleForTesting Link computeLink(final AccountSettings nextHopAccountSettings, final InterledgerAddress destinationAddress) { if (localDestinationAddressUtils.isLocalSpspDestinationAddress(destinationAddress)) { return this.linkManager.getOrCreateSpspReceiverLink(nextHopAccountSettings); } else { return this.linkManager.getOrCreateLink(nextHopAccountSettings); } } DefaultPacketSwitchFilterChain(
final PacketRejector packetRejector,
final List<PacketSwitchFilter> packetSwitchFilters,
final List<LinkFilter> linkFilters,
final LocalDestinationAddressUtils localDestinationAddressUtils,
final LinkManager linkManager,
final NextHopPacketMapper nextHopPacketMapper,
final AccountSettingsLoadingCache accountSettingsLoadingCache,
final PacketEventPublisher packetEventPublisher
); @Override InterledgerResponsePacket doFilter(
final AccountSettings sourceAccountSettings, final InterledgerPreparePacket preparePacket
); } | @Test public void computeLinkForLocalSpsp() { when(localDestinationAddressUtilsMock.isLocalSpspDestinationAddress(any())).thenReturn(true); filterChain.computeLink(INCOMING_ACCOUNT_SETTINGS, InterledgerAddress.of("example.foo")); verify(linkManagerMock).getOrCreateSpspReceiverLink(INCOMING_ACCOUNT_SETTINGS); verifyNoMoreInteractions(linkManagerMock); }
@Test public void computeLinkForForwardingAccount() { when(localDestinationAddressUtilsMock.isLocalSpspDestinationAddress(any())).thenReturn(false); filterChain.computeLink(INCOMING_ACCOUNT_SETTINGS, InterledgerAddress.of("example.foo")); verify(linkManagerMock).getOrCreateLink(INCOMING_ACCOUNT_SETTINGS); verifyNoMoreInteractions(linkManagerMock); } |
MaxPacketAmountFilter extends AbstractPacketFilter implements PacketSwitchFilter { @Override public InterledgerResponsePacket doFilter( final AccountSettings sourceAccountSettings, final InterledgerPreparePacket sourcePreparePacket, final PacketSwitchFilterChain filterChain ) { Objects.requireNonNull(sourceAccountSettings); Objects.requireNonNull(sourcePreparePacket); Objects.requireNonNull(filterChain); return sourceAccountSettings.maximumPacketAmount() .filter(maxPacketAmount -> sourcePreparePacket.getAmount().compareTo(maxPacketAmount) > 0) .map(maxPacketAmount -> { logger.error( "Rejecting packet for exceeding max amount. accountId={} maxAmount={} actualAmount={}", sourceAccountSettings.accountId(), maxPacketAmount, sourcePreparePacket.getAmount() ); return (InterledgerResponsePacket) packetRejector.reject( LinkId.of(sourceAccountSettings.accountId().value()), sourcePreparePacket, InterledgerErrorCode.F08_AMOUNT_TOO_LARGE, String.format( "Packet size too large: maxAmount=%s actualAmount=%s", maxPacketAmount, sourcePreparePacket.getAmount()) ); }) .orElseGet(() -> filterChain.doFilter(sourceAccountSettings, sourcePreparePacket)); } MaxPacketAmountFilter(final PacketRejector packetRejector); @Override InterledgerResponsePacket doFilter(
final AccountSettings sourceAccountSettings,
final InterledgerPreparePacket sourcePreparePacket,
final PacketSwitchFilterChain filterChain
); } | @Test public void filterHatesNullSettings() { MaxPacketAmountFilter filter = createFilter(); expectedException.expect(NullPointerException.class); filter.doFilter(null, createPrepareWithAmount(10), filterChain); }
@Test public void filterHatesNullPrepare() { MaxPacketAmountFilter filter = createFilter(); expectedException.expect(NullPointerException.class); filter.doFilter(createAccountSettingsWithMaxAmount(UnsignedLong.valueOf(100)), null, filterChain); }
@Test public void filterHatesNullChain() { MaxPacketAmountFilter filter = createFilter(); expectedException.expect(NullPointerException.class); filter.doFilter(createAccountSettingsWithMaxAmount(UnsignedLong.valueOf(100)), createPrepareWithAmount(10), null); }
@Test public void passAlongWhenBelowMax() { MaxPacketAmountFilter filter = createFilter(); AccountSettings settings = createAccountSettingsWithMaxAmount(UnsignedLong.valueOf(1000)); InterledgerPreparePacket prepare = createPrepareWithAmount(999); filter.doFilter(settings, prepare, filterChain); verify(filterChain, times(1)).doFilter(settings, prepare); }
@Test public void rejectWhenBeyondMax() { MaxPacketAmountFilter filter = createFilter(); AccountSettings settings = createAccountSettingsWithMaxAmount(UnsignedLong.valueOf(1000)); InterledgerPreparePacket prepare = createPrepareWithAmount(1001); InterledgerResponsePacket response = filter.doFilter(settings, prepare, filterChain); assertThat(response).isInstanceOf(InterledgerRejectPacket.class) .extracting("code", "message") .containsExactly(InterledgerErrorCode.F08_AMOUNT_TOO_LARGE, "Packet size too large: maxAmount=1000 actualAmount=1001"); verify(filterChain, times(0)).doFilter(settings, prepare); } |
PacketMetricsFilter extends AbstractPacketFilter implements PacketSwitchFilter { @Override public InterledgerResponsePacket doFilter( final AccountSettings sourceAccountSettings, final InterledgerPreparePacket sourcePreparePacket, final PacketSwitchFilterChain filterChain ) { try { this.metricsService.trackIncomingPacketPrepared(sourceAccountSettings, sourcePreparePacket); return filterChain.doFilter(sourceAccountSettings, sourcePreparePacket) .map( (interledgerFulfillPacket) -> { this.metricsService.trackIncomingPacketFulfilled(sourceAccountSettings, interledgerFulfillPacket); return interledgerFulfillPacket; }, (interledgerRejectPacket) -> { this.metricsService.trackIncomingPacketRejected(sourceAccountSettings, interledgerRejectPacket); return interledgerRejectPacket; } ); }catch (InterledgerProtocolException e) { this.metricsService.trackIncomingPacketRejected(sourceAccountSettings, e.getInterledgerRejectPacket()); throw e; } catch (Exception e) { this.metricsService.trackIncomingPacketFailed(sourceAccountSettings); throw e; } } PacketMetricsFilter(final PacketRejector packetRejector, MetricsService metricsService); @Override InterledgerResponsePacket doFilter(
final AccountSettings sourceAccountSettings,
final InterledgerPreparePacket sourcePreparePacket,
final PacketSwitchFilterChain filterChain
); } | @Test public void doFilterWithFulfill() { when(filterChainMock.doFilter(accountSettings(), preparePacket())).thenReturn(fulfillPacket()); final InterledgerResponsePacket actual = filter.doFilter(accountSettings(), preparePacket(), filterChainMock); assertThat(actual).isEqualTo(fulfillPacket()); verifyNoMoreInteractions(packetRejectorMock); verify(metricsServiceMock).trackIncomingPacketPrepared(accountSettings(), preparePacket()); verify(metricsServiceMock).trackIncomingPacketFulfilled(accountSettings(), fulfillPacket()); verifyNoMoreInteractions(metricsServiceMock); }
@Test public void doFilterWithReject() { when(filterChainMock.doFilter(accountSettings(), preparePacket())).thenReturn(rejectPacket()); final InterledgerResponsePacket actual = filter.doFilter(accountSettings(), preparePacket(), filterChainMock); assertThat(actual).isEqualTo(rejectPacket()); verifyNoMoreInteractions(packetRejectorMock); verify(metricsServiceMock).trackIncomingPacketPrepared(accountSettings(), preparePacket()); verify(metricsServiceMock).trackIncomingPacketRejected(accountSettings(), rejectPacket()); verifyNoMoreInteractions(metricsServiceMock); }
@Test public void doFilterWithInterledgerProtocolException() { final AccountSettings accountSettings = accountSettings(); final InterledgerPreparePacket preparePacket = preparePacket(); expectedException.expect(InterledgerProtocolException.class); expectedException.expectMessage("Interledger Rejection: "); doThrow(new InterledgerProtocolException(rejectPacket())) .when(filterChainMock) .doFilter(eq(accountSettings), eq(preparePacket)); try { filter.doFilter(accountSettings, preparePacket, filterChainMock); fail("cannot run doFilter"); } catch (Exception e) { verifyNoMoreInteractions(packetRejectorMock); verify(metricsServiceMock).trackIncomingPacketPrepared(accountSettings, preparePacket); verify(metricsServiceMock).trackIncomingPacketRejected(accountSettings, rejectPacket()); verifyNoMoreInteractions(metricsServiceMock); throw e; } }
@Test public void doFilterWithException() { final AccountSettings accountSettings = accountSettings(); final InterledgerPreparePacket preparePacket = preparePacket(); expectedException.expect(RuntimeException.class); expectedException.expectMessage("foo"); doThrow(new RuntimeException("foo")).when(filterChainMock).doFilter(eq(accountSettings), eq(preparePacket)); try { filter.doFilter(accountSettings, preparePacket, filterChainMock); fail("cannot run doFilter"); } catch (Exception e) { verifyNoMoreInteractions(packetRejectorMock); verify(metricsServiceMock).trackIncomingPacketPrepared(accountSettings, preparePacket); verify(metricsServiceMock).trackIncomingPacketFailed(accountSettings); verifyNoMoreInteractions(metricsServiceMock); throw e; } } |
SpspRequestMatcher implements RequestMatcher { @Override public boolean matches(final HttpServletRequest httpServletRequest) { return spspEnabled && hasCorrectSpspUrlPath(httpServletRequest) && hasCorrectAcceptHeader(httpServletRequest); } SpspRequestMatcher(final boolean spspEnabled, final String initialSpspUrlPath); @Override boolean matches(final HttpServletRequest httpServletRequest); } | @Test public void testWhenDisabled() { this.spspRequestMatcher = new SpspRequestMatcher(false, "/p"); servletRequest.removeHeader("Accept"); servletRequest.addHeader("Accept", "text/plain"); assertThat(spspRequestMatcher.matches(servletRequest)).isFalse(); servletRequest.removeHeader("Accept"); servletRequest.addHeader("Accept", "application/spsp4+json"); assertThat(spspRequestMatcher.matches(servletRequest)).isFalse(); servletRequest.setServletPath("/p/bob"); assertThat(spspRequestMatcher.matches(servletRequest)).isFalse(); servletRequest.setServletPath("/q/bob"); assertThat(spspRequestMatcher.matches(servletRequest)).isFalse(); }
@Test public void testWhenEnabled() { this.spspRequestMatcher = new SpspRequestMatcher(true, "/p"); servletRequest.setRequestURI("/p/bob"); servletRequest.removeHeader("Accept"); servletRequest.addHeader("Accept", "text/plain"); assertThat(spspRequestMatcher.matches(servletRequest)).isFalse(); servletRequest.setRequestURI("/p/bob"); servletRequest.removeHeader("Accept"); servletRequest.addHeader("Accept", "application/spsp4+json"); assertThat(spspRequestMatcher.matches(servletRequest)).isTrue(); servletRequest.setRequestURI("/p/bob"); servletRequest.removeHeader("Accept"); servletRequest.addHeader("Accept", "text/html, application/spsp4+json"); assertThat(spspRequestMatcher.matches(servletRequest)).isTrue(); servletRequest.setRequestURI("/p/bob"); servletRequest.removeHeader("Accept"); servletRequest.addHeader("Accept", "application/spsp4+json,application/spsp+json"); assertThat(spspRequestMatcher.matches(servletRequest)).isTrue(); servletRequest.setRequestURI("/p/bob"); servletRequest.removeHeader("Accept"); servletRequest.addHeader("Accept", "application/spsp4+json,application/spsp+json"); assertThat(spspRequestMatcher.matches(servletRequest)).isTrue(); servletRequest.setRequestURI("/q/bob"); servletRequest.removeHeader("Accept"); servletRequest.addHeader("Accept", "application/spsp4+json,application/spsp+json"); assertThat(spspRequestMatcher.matches(servletRequest)).isFalse(); } |
InterledgerAddressUtils { public boolean isExternalForwardingAllowed(final InterledgerAddress destinationAddress) { Objects.requireNonNull(destinationAddress); if (destinationAddress.startsWith(connectorSettingsSupplier.get().operatorAddress())) { return EXTERNAL_FORWARDING_NOT_ALLOWED; } else if ( isPaymentNetworkAddress(destinationAddress) ) { return EXTERNAL_FORWARDING_ALLOWED; } else { return EXTERNAL_FORWARDING_NOT_ALLOWED; } } InterledgerAddressUtils(
final Supplier<ConnectorSettings> connectorSettingsSupplier,
final AccountSettingsRepository accountSettingsRepository
); boolean isExternalForwardingAllowed(final InterledgerAddress destinationAddress); boolean isDestinationAllowedFromAccount(
final AccountId sourceAccountId, final InterledgerAddress destinationAddress
); } | @Test public void isExternalForwardingAllowedWithNull() { expectedException.expect(NullPointerException.class); interledgerAddressUtils.isExternalForwardingAllowed(null); }
@Test public void isExternalForwardingAllowed() { when(connectorSettingsMock.operatorAddress()).thenReturn(InterledgerAddress.of("test.bar")); assertThat(interledgerAddressUtils.isExternalForwardingAllowed(InterledgerAddress.of("test.bar"))).isFalse(); assertThat(interledgerAddressUtils.isExternalForwardingAllowed(InterledgerAddress.of("test.bar.bar"))).isFalse(); assertThat(interledgerAddressUtils.isExternalForwardingAllowed(InterledgerAddress.of("test.b"))).isTrue(); assertThat(interledgerAddressUtils.isExternalForwardingAllowed(InterledgerAddress.of("g.foo"))).isTrue(); assertThat(interledgerAddressUtils.isExternalForwardingAllowed(InterledgerAddress.of("test.foo"))).isTrue(); assertThat(interledgerAddressUtils.isExternalForwardingAllowed(InterledgerAddress.of("test1.foo"))).isTrue(); assertThat(interledgerAddressUtils.isExternalForwardingAllowed(InterledgerAddress.of("test2.foo"))).isTrue(); assertThat(interledgerAddressUtils.isExternalForwardingAllowed(InterledgerAddress.of("test3.foo"))).isTrue(); assertThat(interledgerAddressUtils.isExternalForwardingAllowed(InterledgerAddress.of("example.foo"))).isFalse(); assertThat(interledgerAddressUtils.isExternalForwardingAllowed(InterledgerAddress.of("private.foo"))).isFalse(); assertThat(interledgerAddressUtils.isExternalForwardingAllowed(InterledgerAddress.of("peer.foo"))).isFalse(); assertThat(interledgerAddressUtils.isExternalForwardingAllowed(InterledgerAddress.of("self.foo"))).isFalse(); assertThat(interledgerAddressUtils.isExternalForwardingAllowed(InterledgerAddress.of("local.foo"))).isFalse(); } |
Subsets and Splits
No saved queries yet
Save your SQL queries to embed, download, and access them later. Queries will appear here once saved.