src_fm_fc_ms_ff
stringlengths 43
86.8k
| target
stringlengths 20
276k
|
|---|---|
ComponentRelationships { public static Set<Dependency> filterDependencies(Collection<Relationship> relationships) { Objects.requireNonNull(relationships, "relationship collection required"); return relationships.stream() .filter(rel -> rel instanceof Dependency) .map(rel -> (Dependency) rel) .collect(Collectors.toSet()); } @JsonCreator ComponentRelationships(@JsonProperty("component") Component component,
@JsonProperty("dependencies") Set<Dependency> dependencies,
@JsonProperty("consumers") Set<Consumer> consumers); static ComponentRelationships of(Component component, Set<Dependency> dependencies,
Set<Consumer> consumers); static ComponentRelationships of(Component component, Collection<Relationship> relationships); static ComponentRelationships of(Component component, Relationship... relationships); static Set<Consumer> filterConsumers(Collection<Relationship> relationships); static Set<Dependency> filterDependencies(Collection<Relationship> relationships); boolean hasRelationships(); @Override int hashCode(); @Override boolean equals(Object o); Component getComponent(); Set<Dependency> getDependencies(); Set<Consumer> getConsumers(); @JsonIgnore Set<Relationship> getRelationships(); static ComponentRelationshipsBuilder builder(); }
|
@Test public void filterDependenciesShouldReturnOnlyDependency() { Set<Dependency> actual = ComponentRelationships .filterDependencies(Arrays.asList(Dependency.on(dependencyComponent), Consumer.by(consumerComponent))); Assert.assertEquals(dependencies, actual); }
|
ComponentRelationships { public static Set<Consumer> filterConsumers(Collection<Relationship> relationships) { Objects.requireNonNull(relationships, "relationship collection required"); return relationships.stream() .filter(rel -> rel instanceof Consumer) .map(rel -> (Consumer) rel) .collect(Collectors.toSet()); } @JsonCreator ComponentRelationships(@JsonProperty("component") Component component,
@JsonProperty("dependencies") Set<Dependency> dependencies,
@JsonProperty("consumers") Set<Consumer> consumers); static ComponentRelationships of(Component component, Set<Dependency> dependencies,
Set<Consumer> consumers); static ComponentRelationships of(Component component, Collection<Relationship> relationships); static ComponentRelationships of(Component component, Relationship... relationships); static Set<Consumer> filterConsumers(Collection<Relationship> relationships); static Set<Dependency> filterDependencies(Collection<Relationship> relationships); boolean hasRelationships(); @Override int hashCode(); @Override boolean equals(Object o); Component getComponent(); Set<Dependency> getDependencies(); Set<Consumer> getConsumers(); @JsonIgnore Set<Relationship> getRelationships(); static ComponentRelationshipsBuilder builder(); }
|
@Test public void filterConsumersShouldReturnOnlyConsumer() { Dependency dependencyB = Dependency.on(dependencyComponent); Consumer consumerC = Consumer.by(consumerComponent); Set<Consumer> expected = new HashSet<>(); expected.add(consumerC); Set<Consumer> actual = ComponentRelationships.filterConsumers(Arrays.asList(dependencyB, consumerC)); Assert.assertEquals(expected, actual); }
|
ComponentRelationships { public static ComponentRelationships of(Component component, Set<Dependency> dependencies, Set<Consumer> consumers) { return new ComponentRelationships(component, dependencies, consumers); } @JsonCreator ComponentRelationships(@JsonProperty("component") Component component,
@JsonProperty("dependencies") Set<Dependency> dependencies,
@JsonProperty("consumers") Set<Consumer> consumers); static ComponentRelationships of(Component component, Set<Dependency> dependencies,
Set<Consumer> consumers); static ComponentRelationships of(Component component, Collection<Relationship> relationships); static ComponentRelationships of(Component component, Relationship... relationships); static Set<Consumer> filterConsumers(Collection<Relationship> relationships); static Set<Dependency> filterDependencies(Collection<Relationship> relationships); boolean hasRelationships(); @Override int hashCode(); @Override boolean equals(Object o); Component getComponent(); Set<Dependency> getDependencies(); Set<Consumer> getConsumers(); @JsonIgnore Set<Relationship> getRelationships(); static ComponentRelationshipsBuilder builder(); }
|
@Test public void staticFactoryMethodUsingRelationshipsShouldReturnSameResultAsConstructor() { Set<Dependency> dependencies = new HashSet<>(); dependencies.add(Dependency.on(dependencyComponent)); Set<Consumer> consumers = new HashSet<>(); consumers.add(Consumer.by(consumerComponent)); ComponentRelationships expected = new ComponentRelationships(component, dependencies, consumers); ComponentRelationships actual = ComponentRelationships.of(component, Arrays.asList(Dependency.on(dependencyComponent), Consumer.by(consumerComponent))); Assert.assertEquals(expected, actual); }
@Test public void staticFactoryMethodUsingDependenciesAndConsumersShouldReturnSameResultAsConstructor() { ComponentRelationships expected = new ComponentRelationships(component, dependencies, consumers); ComponentRelationships actual = ComponentRelationships.of(component, dependencies, consumers); Assert.assertEquals(expected, actual); }
|
ComponentRelationships { public static ComponentRelationshipsBuilder builder() { return new ComponentRelationshipsBuilder(); } @JsonCreator ComponentRelationships(@JsonProperty("component") Component component,
@JsonProperty("dependencies") Set<Dependency> dependencies,
@JsonProperty("consumers") Set<Consumer> consumers); static ComponentRelationships of(Component component, Set<Dependency> dependencies,
Set<Consumer> consumers); static ComponentRelationships of(Component component, Collection<Relationship> relationships); static ComponentRelationships of(Component component, Relationship... relationships); static Set<Consumer> filterConsumers(Collection<Relationship> relationships); static Set<Dependency> filterDependencies(Collection<Relationship> relationships); boolean hasRelationships(); @Override int hashCode(); @Override boolean equals(Object o); Component getComponent(); Set<Dependency> getDependencies(); Set<Consumer> getConsumers(); @JsonIgnore Set<Relationship> getRelationships(); static ComponentRelationshipsBuilder builder(); }
|
@Test public void builderShouldReturnSameResultAsConstructor() { ComponentRelationships expected = new ComponentRelationships(component, dependencies, consumers); ComponentRelationships actual = ComponentRelationships.builder() .component(component) .dependencies(dependencies) .consumers(consumers) .build(); Assert.assertEquals(expected, actual); }
@Test public void builderAddConsumerShouldAppend() { ComponentRelationships expected = new ComponentRelationships(component, dependencies, consumers); ComponentRelationships actual = ComponentRelationships.builder() .component(component) .dependencies(dependencies) .addConsumer(Consumer.by(consumerComponent)) .build(); Assert.assertEquals(expected, actual); }
@Test public void builderAddDependencyShouldAppend() { ComponentRelationships expected = new ComponentRelationships(component, dependencies, consumers); ComponentRelationships actual = ComponentRelationships.builder() .component(component) .addDependency(Dependency.on(dependencyComponent)) .consumers(consumers) .build(); Assert.assertEquals(expected, actual); }
|
CompositeRelationshipDetector implements RelationshipDetector { @Override public Set<Relationship> detect() { return detectors.stream() .map(RelationshipDetector::detect) .flatMap(Collection::stream) .collect(Collectors.toSet()); } CompositeRelationshipDetector(Collection<RelationshipDetector> detectors); @Override Set<Relationship> detect(); }
|
@Test public void detectShouldContainRelationshipDetectedByBothSources() { FixedRelationshipDetector detector1 = new FixedRelationshipDetector(Arrays.asList(TestHelper.dependencyOnB())); FixedRelationshipDetector detector2 = new FixedRelationshipDetector( TestHelper.relationshipSetOfDependencyBAndConsumerC()); CompositeRelationshipDetector compositeDetector = new CompositeRelationshipDetector( Arrays.asList(detector1, detector2)); Set<Relationship> expected = TestHelper.relationshipSetOfDependencyBAndConsumerC(); Assert.assertEquals(expected, compositeDetector.detect()); }
|
System { public static System empty(String name) { return System.of(name); } System(String name, Collection<ComponentRelationships> rels, Collection<ResolutionError> errors); System(String name, Collection<ComponentRelationships> rels); static System of(String name, Collection<ComponentRelationships> rels); static System of(String name, Collection<ComponentRelationships> rels, Collection<ResolutionError> errors); static System of(String name, ComponentRelationships... rels); static System empty(String name); boolean hasErrors(); @Override boolean equals(Object o); @Override int hashCode(); String getName(); Set<ComponentRelationships> getComponentRelationships(); Set<ResolutionError> getErrors(); static SystemBuilder builder(); }
|
@Test public void testToString() { String toString = System.empty("xmen").toString(); Assertions.assertThat(toString).contains("xmen"); }
|
ConsumerProperties { public Consumer toConsumer() { return Consumer.by(component.toComponent()); } Consumer toConsumer(); }
|
@Test public void toConsumerModel() { ConsumerProperties c = new ConsumerProperties(); ComponentProperties cmp = new ComponentProperties(); c.setComponent(cmp); cmp.setName("gambit"); cmp.setType("superhero"); Assert.assertEquals(Consumer.by(Component.of("gambit", "superhero")), c.toConsumer()); }
|
DependencyProperties { public Dependency toDependency() { return Dependency.on(component.toComponent()); } Dependency toDependency(); }
|
@Test public void toDependency() { DependencyProperties c = new DependencyProperties(); ComponentProperties cmp = new ComponentProperties(); c.setComponent(cmp); cmp.setName("magneto"); cmp.setType("villain"); Assert.assertEquals(Dependency.on(Component.of("magneto", "villain")), c.toDependency()); }
|
CereebroSnitchMvcEndpoint extends AbstractMvcEndpoint implements SnitchEndpoint { @Override public URI getUri() { return URI.create(getPath()); } CereebroSnitchMvcEndpoint(ApplicationAnalyzer analyzer); @Override URI getUri(); @RequestMapping(method = RequestMethod.GET) @ResponseBody @Override SystemFragment snitch(); static final String DEFAULT_PATH; }
|
@Test public void location() { Assert.assertEquals(URI.create("/cereebro/snitch"), endpoint.getUri()); }
|
CereebroSnitchMvcEndpoint extends AbstractMvcEndpoint implements SnitchEndpoint { @RequestMapping(method = RequestMethod.GET) @ResponseBody @Override public SystemFragment snitch() { return applicationAnalyzer.analyzeSystem(); } CereebroSnitchMvcEndpoint(ApplicationAnalyzer analyzer); @Override URI getUri(); @RequestMapping(method = RequestMethod.GET) @ResponseBody @Override SystemFragment snitch(); static final String DEFAULT_PATH; }
|
@Test public void snitch() { Dependency d1 = Dependency.on(Component.of("cards", "game")); Consumer c1 = Consumer.by(Component.of("angel", "superhero")); ComponentRelationships rels = ComponentRelationships.builder().component(Component.of("gambit", "xmen")) .addDependency(d1).addConsumer(c1).build(); Mockito.when(analyzer.analyzeSystem()).thenReturn(SystemFragment.of(rels)); SystemFragment actual = endpoint.snitch(); Set<Dependency> dependencies = new HashSet<>(Arrays.asList(d1)); Set<Consumer> consumers = new HashSet<>(Arrays.asList(c1)); ComponentRelationships r = ComponentRelationships.of(Component.of("gambit", "xmen"), dependencies, consumers); SystemFragment expected = SystemFragment.of(r); Assert.assertEquals(expected, actual); }
|
Slf4jSnitchLogger implements CommandLineRunner { public void log() { if (LOGGER.isInfoEnabled()) { try { SystemFragment frag = analyzer.analyzeSystem(); String fragString = objectMapper.writeValueAsString(frag); LOGGER.info("System fragment : {}", fragString); } catch (IOException | RuntimeException e) { LOGGER.error("Error while logging system fragment", e); } } } Slf4jSnitchLogger(ApplicationAnalyzer analyzer, ObjectMapper objectMapper); void log(); @Override void run(String... args); }
|
@Test public void log() throws IOException { Level previousLogLevel = setLogLevel(Slf4jSnitchLogger.class, Level.INFO); SystemFragment frag = SystemFragment.empty(); Mockito.when(analyzerMock.analyzeSystem()).thenReturn(frag); Mockito.when(objectMapperMock.writeValueAsString(frag)).thenReturn(""); logSnitch.log(); Mockito.verify(analyzerMock).analyzeSystem(); Mockito.verify(objectMapperMock).writeValueAsString(frag); setLogLevel(Slf4jSnitchLogger.class, previousLogLevel); }
@Test public void logInfoDisabledShouldNotLog() throws IOException { Level previousLogLevel = setLogLevel(Slf4jSnitchLogger.class, Level.ERROR); logSnitch.log(); Mockito.verify(analyzerMock, Mockito.never()).analyzeSystem(); Mockito.verify(objectMapperMock, Mockito.never()).writeValueAsString(Mockito.any()); setLogLevel(Slf4jSnitchLogger.class, previousLogLevel); }
@Test public void logShouldSwallowExceptions() throws JsonProcessingException { SystemFragment frag = SystemFragment.empty(); Mockito.when(analyzerMock.analyzeSystem()).thenReturn(frag); Mockito.when(objectMapperMock.writeValueAsString(frag)).thenThrow(Mockito.mock(JsonGenerationException.class)); logSnitch.log(); Mockito.verify(analyzerMock).analyzeSystem(); Mockito.verify(objectMapperMock).writeValueAsString(frag); }
|
ComponentProperties { public Component toComponent() { return Component.of(name, type); } Component toComponent(); }
|
@Test public void toComponent() { ComponentProperties c = new ComponentProperties(); c.setName("wolverine"); c.setType("superhero"); Component expected = Component.of("wolverine", "superhero"); Component actual = c.toComponent(); Assert.assertEquals(expected, actual); }
|
SpringBootApplicationAnalyzer implements ApplicationAnalyzer { @Override public SystemFragment analyzeSystem() { return SystemFragment.of(Collections.singleton(analyzeApplication())); } SpringBootApplicationAnalyzer(CereebroProperties cereebroProperties,
Collection<RelationshipDetector> detectors); @Override ComponentRelationships analyzeApplication(); @Override SystemFragment analyzeSystem(); }
|
@Test public void analyzeSystem() { Mockito.when(detectorMock.detect()).thenReturn(new HashSet<>()); SystemFragment result = analyzer.analyzeSystem(); ComponentRelationships rels = ComponentRelationships.builder().component(Component.of("name", "type")).build(); Assertions.assertThat(result).isEqualTo(SystemFragment.of(rels)); }
|
ConfigurationPropertiesRelationshipDetector implements RelationshipDetector { @Override public Set<Relationship> detect() { return properties.getApplication().getRelationships(); } ConfigurationPropertiesRelationshipDetector(CereebroProperties properties); @Override Set<Relationship> detect(); }
|
@Test public void detectRelationshipsBasedOnPropertiesShouldReturnDependenciesAndConsumers() { CereebroProperties properties = new CereebroProperties(); ComponentRelationshipsProperties application = new ComponentRelationshipsProperties(); DependencyProperties d = new DependencyProperties(); ConsumerProperties c = new ConsumerProperties(); ComponentProperties consumer = new ComponentProperties(); consumer.setName("apocalypse"); consumer.setType("villain"); c.setComponent(consumer); application.setConsumers(Arrays.asList(c)); ComponentProperties dependency = new ComponentProperties(); dependency.setName("wolverine"); dependency.setType("superhero"); d.setComponent(dependency); application.setDependencies(Arrays.asList(d)); properties.setApplication(application); Set<Relationship> expected = new HashSet<>(Arrays.asList(Dependency.on(Component.of("wolverine", "superhero")), Consumer.by(Component.of("apocalypse", "villain")))); ConfigurationPropertiesRelationshipDetector detector = new ConfigurationPropertiesRelationshipDetector( properties); Set<Relationship> actual = detector.detect(); Assert.assertEquals(expected, actual); }
@Test public void detectPropertiesWithoutRelationshipsShouldReturnEmptySet() { Set<Relationship> expected = new HashSet<>(); ConfigurationPropertiesRelationshipDetector detector = new ConfigurationPropertiesRelationshipDetector( new CereebroProperties()); Set<Relationship> actual = detector.detect(); Assert.assertEquals(expected, actual); }
|
System { public static SystemBuilder builder() { return new SystemBuilder(); } System(String name, Collection<ComponentRelationships> rels, Collection<ResolutionError> errors); System(String name, Collection<ComponentRelationships> rels); static System of(String name, Collection<ComponentRelationships> rels); static System of(String name, Collection<ComponentRelationships> rels, Collection<ResolutionError> errors); static System of(String name, ComponentRelationships... rels); static System empty(String name); boolean hasErrors(); @Override boolean equals(Object o); @Override int hashCode(); String getName(); Set<ComponentRelationships> getComponentRelationships(); Set<ResolutionError> getErrors(); static SystemBuilder builder(); }
|
@Test public void builderTest() { System actual = System.builder().name(NAME).componentRelationships(new HashSet<>()).errors(new HashSet<>()) .build(); Assertions.assertThat(System.empty(NAME)).isEqualTo(actual); }
|
EurekaMetadataPopulator { public void populate() { try { Map<String, String> metadata = appInfoManager.getEurekaInstanceConfig().getMetadataMap(); metadata.put(CereebroMetadata.KEY_SNITCH_URI, getEndpointUri().toString()); String frag = objectMapper.writeValueAsString(snitch.snitch()); metadata.put(CereebroMetadata.KEY_SNITCH_SYSTEM_FRAGMENT_JSON, frag); appInfoManager.registerAppMetadata(metadata); } catch (IOException e) { throw new SnitchingException(snitch.getUri(), "Error while serializing fragment", e); } } EurekaMetadataPopulator(SnitchEndpoint snitch, ApplicationInfoManager manager,
EurekaInstanceSnitchProperties props, ObjectMapper mapper); void populate(); }
|
@Test public void populateEurekaMetadaFromSnitch() { populator.populate(); Assertions.assertThat(metadata).isNotEmpty(); Assertions.assertThat(metadata).containsEntry(CereebroMetadata.KEY_SNITCH_URI, DEFAULT_URL); }
@Test public void populateEurekaMetadaFromAbsolutePath() { props.setEndpointUrl(DEFAULT_URL); populator.populate(); Assertions.assertThat(metadata).containsEntry(CereebroMetadata.KEY_SNITCH_URI, DEFAULT_URL); }
@Test public void populateEurekaMetadaFromRelativePath() { final String urlPath = "/cereebro"; props.setEndpointUrlPath(urlPath); populator.populate(); Assertions.assertThat(metadata).containsEntry(CereebroMetadata.KEY_SNITCH_URI, DEFAULT_URL); }
@Test public void populateWhenBothPathsShouldPreferAbsoluteUrl() { props.setEndpointUrl(DEFAULT_URL); props.setEndpointUrlPath("/whatever"); populator.populate(); Assertions.assertThat(metadata).containsEntry(CereebroMetadata.KEY_SNITCH_URI, DEFAULT_URL); }
@Test public void ioExceptionWhilePopulatingMetadataShouldBeConvertedToSnitchingException() throws IOException { ObjectMapper objectMapperMock = Mockito.mock(ObjectMapper.class); SystemFragment frag = SystemFragment.empty(); Mockito.when(snitch.snitch()).thenReturn(frag); EurekaMetadataPopulator pop = new EurekaMetadataPopulator(snitch, appInfoManager, props, objectMapperMock); Mockito.when(objectMapperMock.writeValueAsString(frag)) .thenThrow(new JsonEOFException(null, null, "unit test")); try { pop.populate(); Assert.fail("SnitchingException expected"); } catch (SnitchingException e) { Assertions.assertThat(e.getSnitchUri()).isEqualTo(TEST_URI); } }
|
ComponentRelationshipsProperties { public Set<Dependency> dependencies() { return dependencies.stream().map(DependencyProperties::toDependency).collect(Collectors.toSet()); } Set<Dependency> dependencies(); Set<Consumer> consumers(); Set<Relationship> getRelationships(); }
|
@Test public void dependenciesEmptyByDefault() { ComponentRelationshipsProperties c = new ComponentRelationshipsProperties(); Assert.assertNotNull(c.dependencies()); Assert.assertTrue(c.dependencies().isEmpty()); }
@Test public void dependencies() { ComponentRelationshipsProperties c = new ComponentRelationshipsProperties(); DependencyProperties d = createDependency("iceman", "superhero"); c.setDependencies(Arrays.asList(d)); Set<Dependency> expected = new HashSet<>(Arrays.asList(Dependency.on(Component.of("iceman", "superhero")))); Set<Dependency> actual = c.dependencies(); Assert.assertEquals(expected, actual); }
|
ComponentRelationshipsProperties { public Set<Consumer> consumers() { return consumers.stream().map(ConsumerProperties::toConsumer).collect(Collectors.toSet()); } Set<Dependency> dependencies(); Set<Consumer> consumers(); Set<Relationship> getRelationships(); }
|
@Test public void consumers() { ComponentRelationshipsProperties c = new ComponentRelationshipsProperties(); ConsumerProperties consumer = createConsumer("galactus", "villain"); c.setConsumers(Arrays.asList(consumer)); Set<Consumer> expected = new HashSet<>(Arrays.asList(Consumer.by(Component.of("galactus", "villain")))); Set<Consumer> actual = c.consumers(); Assert.assertEquals(expected, actual); }
|
ComponentRelationshipsProperties { public Set<Relationship> getRelationships() { return Stream.concat(dependencies().stream(), consumers().stream()).collect(Collectors.toSet()); } Set<Dependency> dependencies(); Set<Consumer> consumers(); Set<Relationship> getRelationships(); }
|
@Test public void relationships() { ComponentRelationshipsProperties c = new ComponentRelationshipsProperties(); DependencyProperties d = createDependency("iceman", "superhero"); ConsumerProperties consumer = createConsumer("galactus", "villain"); c.setConsumers(Arrays.asList(consumer)); c.setDependencies(Arrays.asList(d)); Set<Relationship> actual = c.getRelationships(); Set<Relationship> expected = new HashSet<>(Arrays.asList(Consumer.by(Component.of("galactus", "villain")), Dependency.on(Component.of("iceman", "superhero")))); Assert.assertEquals(expected, actual); }
|
Component { public static Component of(String name, String type) { return new Component(name, type); } @JsonCreator Component(@JsonProperty("name") String name, @JsonProperty("type") String type); static Component of(String name, String type); @Override int hashCode(); @Override boolean equals(Object o); String asString(); String getName(); String getType(); }
|
@Test(expected = NullPointerException.class) public void constructorWithNullNameShouldThrowNullPointerException() { Component.of(null, "type"); }
@Test(expected = NullPointerException.class) public void constructorWithNullTypeShouldThrowNullPointerException() { Component.of("name", null); }
@Test public void testToString() { String toString = Component.of("cyclop", "superhero").toString(); java.lang.System.out.println(toString); Assert.assertTrue(toString.contains("cyclop")); Assert.assertTrue(toString.contains("superhero")); }
@Test public void equalsShouldIgnoreNameCase() { Assertions.assertThat(Component.of("C", "c")).isEqualTo(Component.of("c", "c")); }
|
RabbitRelationshipDetector implements RelationshipDetector { @Override public Set<Relationship> detect() { if (connectionFactories.isEmpty()) { return Collections.emptySet(); } return connectionFactories.stream().map(factory -> createRabbitDependency(factory.getVirtualHost())) .collect(Collectors.toSet()); } RabbitRelationshipDetector(List<ConnectionFactory> rabbitConnectionFactories); @Override Set<Relationship> detect(); }
|
@Test public void nullConnectionsShouldReturnEmptyRelationships() { RabbitRelationshipDetector detector = new RabbitRelationshipDetector(null); Assertions.assertThat(detector.detect()).isEmpty(); }
@Test public void emptyConnectionsShouldReturnEmptyRelationships() { RabbitRelationshipDetector detector = new RabbitRelationshipDetector(new ArrayList<>()); Assertions.assertThat(detector.detect()).isEmpty(); }
@Test public void connectionsShouldReturnDependenciesOnRabbitMqVhost() { ConnectionFactory factory = Mockito.mock(ConnectionFactory.class); Mockito.when(factory.getVirtualHost()).thenReturn("vhost"); RabbitRelationshipDetector detector = new RabbitRelationshipDetector(Arrays.asList(factory)); Dependency dependency = Dependency.on(Component.of("vhost", ComponentType.RABBITMQ)); Assertions.assertThat(detector.detect()).isEqualTo(new HashSet<>(Arrays.asList(dependency))); }
|
LdapRelationshipDetector implements RelationshipDetector { @Override public Set<Relationship> detect() { if (contextSources.isEmpty()) { return Collections.emptySet(); } return Dependency.on(Component.of(defaultName, ComponentType.LDAP)).asRelationshipSet(); } LdapRelationshipDetector(List<ContextSource> sources); @Override Set<Relationship> detect(); }
|
@Test public void detectNullShouldReturnEmptyDependencies() { Set<Relationship> actual = new LdapRelationshipDetector(null).detect(); Assertions.assertThat(actual).isEmpty(); }
@Test public void detectEmptyContextSourcesShouldReturnEmptyDependencies() { Set<Relationship> actual = new LdapRelationshipDetector(Collections.emptyList()).detect(); Assertions.assertThat(actual).isEmpty(); }
@Test public void detectSingleContextSourceShouldReturnSingleDependency() { ContextSource ctx = Mockito.mock(ContextSource.class); LdapRelationshipDetector detector = new LdapRelationshipDetector(Arrays.asList(ctx)); Set<Relationship> actual = detector.detect(); Dependency dependency = Dependency.on(Component.of("default", "directory/ldap")); Set<Relationship> expected = new HashSet<>(); expected.add(dependency); Assertions.assertThat(actual).isEqualTo(expected); }
@Test public void detectManyContextSourcesShouldReturnSingleDependency() { List<ContextSource> contextSources = Arrays.asList(Mockito.mock(ContextSource.class), Mockito.mock(ContextSource.class)); LdapRelationshipDetector detector = new LdapRelationshipDetector(contextSources); Set<Relationship> actual = detector.detect(); Dependency dependency = Dependency.on(Component.of("default", "directory/ldap")); Set<Relationship> expected = new HashSet<>(); expected.add(dependency); Assertions.assertThat(actual).isEqualTo(expected); }
@Test public void detectContextSourceWithCustomNameShouldCustomizeDependency() { ContextSource ctx = Mockito.mock(ContextSource.class); LdapRelationshipDetector detector = new LdapRelationshipDetector(Arrays.asList(ctx)); String name = "dir"; detector.setDefaultName(name); Set<Relationship> actual = detector.detect(); Dependency dependency = Dependency.on(Component.of(name, "directory/ldap")); Set<Relationship> expected = new HashSet<>(); expected.add(dependency); Assertions.assertThat(detector.getDefaultName()).isEqualTo(name); Assertions.assertThat(actual).isEqualTo(expected); }
|
AuthorizationServerRelationshipDetector implements RelationshipDetector { @Override public Set<Relationship> detect() { if (tokenService instanceof RemoteTokenServices || tokenService instanceof UserInfoTokenServices) { return Dependency.on(Component.of(getDefaultName(), ComponentType.HTTP_APPLICATION)).asRelationshipSet(); } return Collections.emptySet(); } AuthorizationServerRelationshipDetector(ResourceServerTokenServices tokenService); @Override Set<Relationship> detect(); }
|
@Test public void usingRemoteTokenServicesShouldReturnDependency() { ResourceServerTokenServices tokenService = new RemoteTokenServices(); detector = new AuthorizationServerRelationshipDetector(tokenService); Set<Relationship> expected = new HashSet<>(Arrays .asList(Dependency.on(Component.of("oauth2-authorization-server", ComponentType.HTTP_APPLICATION)))); Set<Relationship> result = detector.detect(); Assertions.assertThat(result).isEqualTo(expected); }
@Test public void usingRemoteTokenServicesWithCustomName() { ResourceServerTokenServices tokenService = new RemoteTokenServices(); detector = new AuthorizationServerRelationshipDetector(tokenService); String customName = "authz"; detector.setDefaultName(customName); Set<Relationship> expected = new HashSet<>( Arrays.asList(Dependency.on(Component.of(customName, ComponentType.HTTP_APPLICATION)))); Set<Relationship> result = detector.detect(); Assertions.assertThat(result).isEqualTo(expected); }
@Test public void usingUserInfoTokenServicesShouldReturnDependency() { ResourceServerTokenServices tokenService = new UserInfoTokenServices("/info", "nope"); detector = new AuthorizationServerRelationshipDetector(tokenService); Set<Relationship> expected = new HashSet<>(Arrays .asList(Dependency.on(Component.of("oauth2-authorization-server", ComponentType.HTTP_APPLICATION)))); Set<Relationship> result = detector.detect(); Assertions.assertThat(result).isEqualTo(expected); }
@Test public void nullTokenServicesShouldReturnEmptyRelationships() { detector = new AuthorizationServerRelationshipDetector(null); Assertions.assertThat(detector.detect()).isEmpty(); }
|
MongoDbRelationshipDetector implements RelationshipDetector { @Override public Set<Relationship> detect() { Set<Relationship> result = new HashSet<>(); for (MongoClient client : clients) { for (String db : client.listDatabaseNames()) { result.add(Dependency.on(Component.of(db, ComponentType.MONGODB))); } } return result; } MongoDbRelationshipDetector(Collection<MongoClient> clients); @Override Set<Relationship> detect(); }
|
@Test public void mongoRelationshipWithSessionAvailable() { Assertions.assertThat(detector.detect()).contains(Dependency.on(Component.of("local", ComponentType.MONGODB))); }
|
RedisRelationshipDetector implements RelationshipDetector { @Override public Set<Relationship> detect() { if (CollectionUtils.isEmpty(connectionFactories)) { return Collections.emptySet(); } String sentinelMaster = getRedisSentinelMasterName(); String name = StringUtils.hasText(sentinelMaster) ? sentinelMaster : defaultName; return Dependency.on(Component.of(name, ComponentType.REDIS)).asRelationshipSet(); } RedisRelationshipDetector(RedisProperties redisProperties,
List<RedisConnectionFactory> redisConnectionFactories); @Override Set<Relationship> detect(); }
|
@Test public void nullSentinelShouldReturnDefaultComponentName() { RedisConnectionFactory factory = Mockito.mock(RedisConnectionFactory.class); RedisRelationshipDetector detector = new RedisRelationshipDetector(new RedisProperties(), Arrays.asList(factory)); Set<Relationship> rels = new HashSet<>(); rels.add(Dependency.on(Component.of("default", ComponentType.REDIS))); Assertions.assertThat(detector.detect()).isEqualTo(rels); }
@Test public void nullArgsShouldReturnEmptyRels() { RedisRelationshipDetector detector = new RedisRelationshipDetector(null, null); Assertions.assertThat(detector.detect()).isEmpty(); }
@Test public void shouldUseSentinelMasterName() { String name = "name"; RedisConnectionFactory factory = Mockito.mock(RedisConnectionFactory.class); RedisProperties props = new RedisProperties(); props.setSentinel(new Sentinel()); props.getSentinel().setMaster(name); RedisRelationshipDetector detector = new RedisRelationshipDetector(props, Arrays.asList(factory)); Set<Relationship> rels = new HashSet<>(); rels.add(Dependency.on(Component.of(name, ComponentType.REDIS))); Assertions.assertThat(detector.detect()).isEqualTo(rels); }
|
EurekaServerRelationshipDetector implements RelationshipDetector { @Override public Set<Relationship> detect() { if (eurekaClients.isEmpty()) { return Collections.emptySet(); } return Dependency.on(Component.of(defaultName, ComponentType.HTTP_APPLICATION_REGISTRY)).asRelationshipSet(); } EurekaServerRelationshipDetector(List<EurekaClient> eurekaClients); @Override Set<Relationship> detect(); }
|
@Test public void nullEurekaClientListShouldReturnEmptyRels() { EurekaServerRelationshipDetector detector = new EurekaServerRelationshipDetector(null); Assertions.assertThat(detector.detect()).isEmpty(); }
@Test public void emptyEurekaClientListShouldReturnEmptyRels() { EurekaServerRelationshipDetector detector = new EurekaServerRelationshipDetector(new ArrayList<>()); Assertions.assertThat(detector.detect()).isEmpty(); }
@Test public void multipleEurekaClientsShouldReturnSingleDependencyOnEurekaServer() { EurekaClient eurekaClientMock = Mockito.mock(EurekaClient.class); EurekaServerRelationshipDetector detector = new EurekaServerRelationshipDetector( Arrays.asList(eurekaClientMock)); Dependency dependency = Dependency.on(Component.of("eureka-server", ComponentType.HTTP_APPLICATION_REGISTRY)); Set<Relationship> expected = new HashSet<>(Arrays.asList(dependency)); Assertions.assertThat(detector.detect()).isEqualTo(expected); }
|
CassandraRelationshipDetector implements RelationshipDetector { @Override public Set<Relationship> detect() { final Set<Relationship> result = new HashSet<>(); for (Session s : sessions) { result.add(Dependency.on(Component.of(extractName(s), ComponentType.CASSANDRA))); } return result; } CassandraRelationshipDetector(Collection<Session> sessions); @Override Set<Relationship> detect(); }
|
@Test public void cassandraRelationshipWithSessionAvailable() { Assertions.assertThat(detector.detect()) .contains(Dependency.on(Component.of("keyspace", ComponentType.CASSANDRA))); }
|
DataSourceRelationshipDetector implements RelationshipDetector { @Override public Set<Relationship> detect() { if (relationsCache == null) { final Set<Relationship> result = new HashSet<>(); for (DataSource ds : dataSources) { try (Connection connection = ds.getConnection()) { result.add(Dependency.on(Component.of(extractName(connection), extractDatabaseType(connection)))); } catch (SQLException e) { LOGGER.error("Could not fetch the default catalog of the database connection", e); } } relationsCache = result; } return new HashSet<>(relationsCache); } DataSourceRelationshipDetector(Collection<DataSource> dataSources); @Override Set<Relationship> detect(); }
|
@Test public void dataSourceRelationshipWithDataSourceAvailable() throws SQLException { Assertions.assertThat(detector.detect()) .contains(Dependency.on(Component.of("catalog", ComponentType.RELATIONAL_DATABASE))); }
|
ZuulRouteRelationshipDetector implements RelationshipDetector { protected boolean containsComponentName(Route route) { return !routeLocationExclusion.matcher(route.getLocation()).matches(); } ZuulRouteRelationshipDetector(RouteLocator routeLocator); @Override Set<Relationship> detect(); }
|
@Test public void routeWithLocationUrlShouldNotContainName() { Route route = routeWithLocation("http: Assertions.assertThat(detector.containsComponentName(route)).isFalse(); }
@Test public void routeWithHttpsUrlLocationShouldNotContainName() { Route route = routeWithLocation("https: Assertions.assertThat(detector.containsComponentName(route)).isFalse(); }
@Test public void routeShouldContainName() { Route route = routeWithLocation("yass"); Assertions.assertThat(detector.containsComponentName(route)).isTrue(); }
|
ZuulRouteRelationshipDetector implements RelationshipDetector { @Override public Set<Relationship> detect() { return routeLocator.getRoutes().stream() .filter(this::containsComponentName) .map(this::createDependency) .collect(Collectors.toSet()); } ZuulRouteRelationshipDetector(RouteLocator routeLocator); @Override Set<Relationship> detect(); }
|
@Test public void detect() { String name = "yass"; List<Route> routes = Arrays.asList(routeWithLocation(name), routeWithLocation("https: routeWithLocation("http: Mockito.when(routeLocatorMock.getRoutes()).thenReturn(routes); Set<Relationship> result = detector.detect(); Component expectedComponent = Component.of(name, ComponentType.HTTP_APPLICATION); Set<Relationship> expected = new HashSet<>(Arrays.asList(Dependency.on(expectedComponent))); Assertions.assertThat(result).isEqualTo(expected); }
|
ElasticSearchRelationshipDetector implements RelationshipDetector { @Override public Set<Relationship> detect() { return clients.stream() .map(c -> Dependency.on(Component.of(c.settings().get("cluster.name"), ComponentType.ELASTIC_SEARCH))) .collect(Collectors.toSet()); } ElasticSearchRelationshipDetector(Collection<Client> esClients); @Override Set<Relationship> detect(); }
|
@Test public void testElasticSearchDetector() { Assertions.assertThat(detector.detect()) .contains(Dependency.on(Component.of("mycluster", ComponentType.ELASTIC_SEARCH))); }
|
CereebroProperties implements EnvironmentAware { @Override public void setEnvironment(Environment env) { if (!StringUtils.hasText(application.getComponent().getName())) { RelaxedPropertyResolver springPropertyResolver = new RelaxedPropertyResolver(env, "spring.application."); String appName = springPropertyResolver.getProperty("name"); application.getComponent().setName(StringUtils.hasText(appName) ? appName : generateName()); } } @Override void setEnvironment(Environment env); }
|
@Test public void setEnvironmentWithSpringApplicationNameShouldSetComponentName() { CereebroProperties c = new CereebroProperties(); MockEnvironment env = new MockEnvironment(); env.setProperty("spring.application.name", "cyclop"); c.setEnvironment(env); Assert.assertEquals("cyclop", c.getApplication().getComponent().getName()); }
@Test public void setEnvironmentWithoutSpringApplicationNameShouldntChangeComponentName() { CereebroProperties c = new CereebroProperties(); c.getApplication().getComponent().setName("storm"); c.setEnvironment(new MockEnvironment()); Assert.assertEquals("storm", c.getApplication().getComponent().getName()); }
|
FileWriterSnitch implements CommandLineRunner, Snitch { @Override public void run(String... args) throws Exception { String location = properties.getSnitch().getFile().getLocation(); try { file = StringUtils.hasText(location) ? new File(location) : File.createTempFile(properties.getApplication().getComponent().getName(), ".json"); write(file); } catch (IOException e) { LOGGER.error("Error while writing JSON to file : " + location, e); } } FileWriterSnitch(ApplicationAnalyzer analyzer, ObjectMapper objectMapper, CereebroProperties properties); @Override void run(String... args); void write(File f); @Override URI getUri(); @Override SystemFragment snitch(); }
|
@Test public void writeToRandomTemporaryFileWhenNoLocationDefined() throws Exception { CereebroProperties properties = new CereebroProperties(); final String componentName = "cereebro-unit-tests"; properties.getApplication().getComponent().setName(componentName); properties.getSnitch().getFile().setLocation(null); FileWriterSnitch snitch = new FileWriterSnitch(analyzerMock, objectMapper, properties); snitch.run(); File tempRoot = new File(System.getProperty("java.io.tmpdir")); File[] tempFiles = tempRoot.listFiles((FilenameFilter) (dir, fileName) -> fileName.contains(componentName)); Assertions.assertThat(tempFiles).isNotEmpty(); Stream.of(tempFiles).forEach(f -> f.deleteOnExit()); }
@Test public void ioExceptionShouldBeSwallowed() throws Exception { CereebroProperties properties = new CereebroProperties(); File temp = temporaryFolder.newFile(); properties.getSnitch().getFile().setLocation(temp.getAbsolutePath()); ObjectMapper messedUpMapperMock = Mockito.mock(ObjectMapper.class); Mockito.when(messedUpMapperMock.writeValueAsString(SystemFragment.empty())) .thenThrow(Mockito.mock(JsonProcessingException.class)); FileWriterSnitch snitch = new FileWriterSnitch(analyzerMock, messedUpMapperMock, properties); snitch.run(); Assertions.assertThat(temp.length()).isEqualTo(0); }
|
Component { public String asString() { return new StringJoiner(":").add(type).add(name).toString(); } @JsonCreator Component(@JsonProperty("name") String name, @JsonProperty("type") String type); static Component of(String name, String type); @Override int hashCode(); @Override boolean equals(Object o); String asString(); String getName(); String getType(); }
|
@Test public void testAsString() { Assert.assertEquals("type:name", Component.of("name", "type").asString()); }
|
FileWriterSnitch implements CommandLineRunner, Snitch { @Override public URI getUri() { if (file == null) { URI uri = URI.create("file: LOGGER.warn("File hasn't been written for some reason, returning default URI : {}", uri); return uri; } return file.toURI(); } FileWriterSnitch(ApplicationAnalyzer analyzer, ObjectMapper objectMapper, CereebroProperties properties); @Override void run(String... args); void write(File f); @Override URI getUri(); @Override SystemFragment snitch(); }
|
@Test public void fileNotWrittenShouldYieldDefaultUri() { FileWriterSnitch snitch = new FileWriterSnitch(analyzerMock, objectMapper, new CereebroProperties()); Assertions.assertThat(snitch.getUri()).isEqualTo(URI.create("file: }
|
DiscoveryClientSnitchRegistry implements SnitchRegistry { @Override public List<Snitch> getAll() { return discoveryClient.getServices().stream() .map(discoveryClient::getInstances) .flatMap(List::stream) .map(instance -> new ServiceInstanceSnitch(objectMapper, instance)) .collect(Collectors.toList()); } DiscoveryClientSnitchRegistry(DiscoveryClient discoveryClient, ObjectMapper mapper); @Override List<Snitch> getAll(); }
|
@Test public void getAllWithSystemFragmentStringShouldReturnStaticSnitch() throws IOException { String serviceId = "fakeServiceId"; Mockito.when(discoveryClientMock.getServices()).thenReturn(Arrays.asList(serviceId)); Mockito.when(discoveryClientMock.getInstances(serviceId)).thenReturn(Arrays.asList(serviceInstanceMock)); Map<String, String> metadata = new HashMap<>(); final String fakeJsonThatWorks = "{ \"valid\" : true }"; final String url = "http: metadata.put(CereebroMetadata.KEY_SNITCH_SYSTEM_FRAGMENT_JSON, fakeJsonThatWorks); metadata.put(CereebroMetadata.KEY_SNITCH_URI, url); Mockito.when(serviceInstanceMock.getMetadata()).thenReturn(metadata); Mockito.when(serviceInstanceMock.getInstanceInfo()).thenReturn(instanceInfoMock); Mockito.when(objectMapperMock.readValue(fakeJsonThatWorks, SystemFragment.class)) .thenReturn(SystemFragment.empty()); List<Snitch> result = registry.getAll(); Assertions.assertThat(result.size()).isEqualTo(1); Snitch snitch = result.get(0); Assertions.assertThat(snitch).isInstanceOf(ServiceInstanceSnitch.class); Assertions.assertThat(URI.create("http: }
|
ServiceInstanceSnitch implements Snitch { public static boolean hasCereebroMetadata(ServiceInstance instance) { return extractSnitchURI(instance).isPresent(); } ServiceInstanceSnitch(ObjectMapper mapper, ServiceInstance instance); static Snitch of(ObjectMapper mapper, ServiceInstance instance); static boolean hasCereebroMetadata(ServiceInstance instance); boolean hasCereebroMetadata(); @Override URI getUri(); @Override SystemFragment snitch(); }
|
@Test public void hasCereebroMetadata() { metadata.put(CereebroMetadata.KEY_SNITCH_URI, "http: Assertions.assertThat(ServiceInstanceSnitch.hasCereebroMetadata(serviceInstanceMock)).isTrue(); }
|
ServiceInstanceSnitch implements Snitch { @Override public SystemFragment snitch() { URI uri = getUri(); String serviceId = serviceInstance.getServiceId(); try { if (hasCereebroMetadata()) { if (StringUtils.hasText(getSystemFragmentJsonString())) { LOGGER.debug("Using snitched system fragment from discovery client - uri : {}", uri); SystemFragment frag = objectMapper.readValue(getSystemFragmentJsonString(), SystemFragment.class); return StaticSnitch.of(uri, frag).snitch(); } else { LOGGER.debug("Using Snitch URL from discovery client - uri : {}", uri); return ResourceSnitch.of(objectMapper, new UrlResource(uri)).snitch(); } } else { LOGGER.debug("No Cereebro metadata, using only the serviceId : {} and instance URI : {}", serviceId, uri); Component service = Component.of(serviceId, ComponentType.HTTP_APPLICATION); return SystemFragment.of(ComponentRelationships.of(service)); } } catch (IOException | RuntimeException e) { LOGGER.warn("Could not create snitch out of service : {} - meta-data : {} - error : {}", serviceId, serviceInstance.getMetadata(), e.getMessage()); throw new SnitchingException(uri, "Error while creating snitch for uri : " + uri + " - service instance : " + serviceId, e); } } ServiceInstanceSnitch(ObjectMapper mapper, ServiceInstance instance); static Snitch of(ObjectMapper mapper, ServiceInstance instance); static boolean hasCereebroMetadata(ServiceInstance instance); boolean hasCereebroMetadata(); @Override URI getUri(); @Override SystemFragment snitch(); }
|
@Test public void snitchErrorShouldThrowSnitchingException() throws IOException { String uri = "http: String json = "{ \"error\" : true }"; metadata.put(CereebroMetadata.KEY_SNITCH_URI, uri); metadata.put(CereebroMetadata.KEY_SNITCH_SYSTEM_FRAGMENT_JSON, json); Mockito.when(objectMapperMock.readValue(json, SystemFragment.class)).thenThrow(new IOException("unit test")); ServiceInstanceSnitch snitch = new ServiceInstanceSnitch(objectMapperMock, serviceInstanceMock); try { snitch.snitch(); Assertions.fail("Expected IOException"); } catch (SnitchingException e) { Assertions.assertThat(e.getSnitchUri()).isEqualTo(URI.create(uri)); } }
|
EurekaServerSnitchRegistry implements SnitchRegistry { @Override public List<Snitch> getAll() { return eurekaServerContext.getRegistry().getSortedApplications().stream() .map(Application::getInstances) .flatMap(Collection::stream) .map(instance -> new ServiceInstanceSnitch(objectMapper, new EurekaServiceInstance(instance))) .collect(Collectors.toList()); } EurekaServerSnitchRegistry(EurekaServerContext eurekaServerContext, ObjectMapper objectMapper); @Override List<Snitch> getAll(); }
|
@Test public void getAllUsingCereebroMetadata() throws IOException { Mockito.when(eurekaServerContextMock.getRegistry()).thenReturn(instanceRegistryMock); String uri = "http: String json = "{}"; Map<String, String> metadata = new HashMap<>(); metadata.put(CereebroMetadata.KEY_SNITCH_URI, uri); metadata.put(CereebroMetadata.KEY_SNITCH_SYSTEM_FRAGMENT_JSON, json); InstanceInfo instanceInfo = InstanceInfo.Builder.newBuilder() .setInstanceId("id") .setAppName("a") .setMetadata(metadata) .build(); Application application = new Application("a", Arrays.asList(instanceInfo)); Mockito.when(instanceRegistryMock.getSortedApplications()).thenReturn(Arrays.asList(application)); Mockito.when(objectMapperMock.readValue(json, SystemFragment.class)).thenReturn(SystemFragment.empty()); List<Snitch> result = registry.getAll(); Assertions.assertThat(result).hasSize(1); Snitch snitch = result.get(0); Assertions.assertThat(snitch.getUri()).isEqualTo(URI.create(uri)); Assertions.assertThat(snitch.snitch()).isEqualTo(SystemFragment.empty()); }
@Test public void getAllWithoutCereebroMetadataShouldUseServiceInstanceInfo() { Mockito.when(eurekaServerContextMock.getRegistry()).thenReturn(instanceRegistryMock); InstanceInfo instanceInfo = InstanceInfo.Builder.newBuilder() .setInstanceId("id") .setAppName("a") .setMetadata(new HashMap<>()) .setHostName("service-instance") .setPort(6090) .build(); Application application = new Application("a", Arrays.asList(instanceInfo)); Mockito.when(instanceRegistryMock.getSortedApplications()).thenReturn(Arrays.asList(application)); List<Snitch> result = registry.getAll(); Assertions.assertThat(result).hasSize(1); Snitch snitch = result.get(0); Assertions.assertThat(snitch.getUri()).isEqualTo(URI.create("http: Component expectedComponent = Component.of("a", ComponentType.HTTP_APPLICATION); SystemFragment expected = SystemFragment.of(ComponentRelationships.of(expectedComponent)); Assertions.assertThat(snitch.snitch()).isEqualTo(expected); }
|
DependencyWheel { public static DependencyWheel of(System system) { final DependencyWheelBuilder builder = DependencyWheel.builder(); List<ComponentRelationships> rels = new ArrayList<>(system.getComponentRelationships()); rels.sort((c1, c2) -> c1.getComponent().asString().compareToIgnoreCase(c2.getComponent().asString())); for (ComponentRelationships rel : rels) { List<Integer> line = new ArrayList<>(); for (ComponentRelationships potentialDependency : rels) { line.add(rel.getDependencies().contains(Dependency.on(potentialDependency.getComponent())) ? 1 : 0); } builder.name(rel.getComponent().getName().toLowerCase()).matrixLine(line); } return builder.build(); } static DependencyWheel of(System system); }
|
@Test public void create() { Component a = Component.of("a", "a"); Component b = Component.of("b", "b"); Component c = Component.of("c", "c"); ComponentRelationships aRels = ComponentRelationships.builder().component(a).addDependency(Dependency.on(b)) .build(); ComponentRelationships bRels = ComponentRelationships.builder().component(b).addDependency(Dependency.on(c)) .build(); ComponentRelationships cRels = ComponentRelationships.builder().component(c).build(); LinkedHashSet<ComponentRelationships> set = new LinkedHashSet<>(); set.add(aRels); set.add(bRels); set.add(cRels); System system = System.of("sys", set); DependencyWheel result = DependencyWheel.of(system); DependencyWheel expected = DependencyWheel.builder() .name("a") .matrixLine(Arrays.asList(0, 1, 0)) .name("b") .matrixLine(Arrays.asList(0, 0, 1)) .name("c") .matrixLine(Arrays.asList(0, 0, 0)) .build(); Assertions.assertThat(result).isEqualTo(expected); }
@Test public void createCyclicDependencies() { Component a = Component.of("a", "a"); Component b = Component.of("b", "b"); ComponentRelationships aRels = ComponentRelationships.builder().component(a).addDependency(Dependency.on(b)) .addDependency(Dependency.on(a)).build(); ComponentRelationships bRels = ComponentRelationships.builder().component(b).addDependency(Dependency.on(a)) .build(); LinkedHashSet<ComponentRelationships> set = new LinkedHashSet<>(); set.add(aRels); set.add(bRels); System system = System.of("sys", set); DependencyWheel result = DependencyWheel.of(system); DependencyWheel expected = DependencyWheel.builder() .name("a") .matrixLine(Arrays.asList(1, 1)) .name("b") .matrixLine(Arrays.asList(1, 0)) .build(); Assertions.assertThat(result).isEqualTo(expected); }
|
Graph { public static Graph of(System system) { Set<Node> nodes = new HashSet<>(); Set<Edge> edges = new HashSet<>(); for (ComponentRelationships rel : system.getComponentRelationships()) { nodes.add(Node.of(rel)); Set<Edge> dependencies = rel.getDependencies().stream().map(d -> Edge.to(rel.getComponent(), d)) .collect(Collectors.toSet()); edges.addAll(dependencies); Set<Edge> consumers = rel.getConsumers().stream().map(c -> Edge.from(rel.getComponent(), c)) .collect(Collectors.toSet()); edges.addAll(consumers); } return Graph.create(nodes, edges); } static Graph of(System system); }
|
@Test public void system() { ComponentRelationships gambit = ComponentRelationships.builder() .component(Component.of("gambit", "superhero")) .addDependency(Dependency.on(Component.of("rogue", "superhero"))) .addConsumer(Consumer.by(Component.of("angel", "superhero"))) .build(); ComponentRelationships rogue = ComponentRelationships.builder() .component(Component.of("rogue", "superhero")) .addConsumer(Consumer.by(Component.of("gambit", "superhero"))) .build(); ComponentRelationships angel = ComponentRelationships.builder() .component(Component.of("angel", "superhero")) .addDependency(Dependency.on(Component.of("gambit", "superhero"))) .build(); System system = System.of("xmen", gambit, angel, rogue); Graph graph = Graph.of(system); Assert.assertEquals(3, graph.getNodes().size()); Edge gambitToRogue = Edge.create("superhero:gambit-to-superhero:rogue", "superhero:gambit", "superhero:rogue"); Edge angelToGambit = Edge.create("superhero:angel-to-superhero:gambit", "superhero:angel", "superhero:gambit"); Set<Edge> expectedEdges = new HashSet<>(Arrays.asList(gambitToRogue, angelToGambit)); Assert.assertEquals(expectedEdges, graph.getEdges()); }
|
CustomHelpFormatter extends BuiltinHelpFormatter { @Override protected String extractTypeIndicator(OptionDescriptor descriptor) { String indicator = descriptor.argumentTypeIndicator(); if (indicator != null) { Class<?> indicatorAsClass = null; try { indicatorAsClass = Class.forName(indicator); } catch (ClassNotFoundException ignore) { } if (indicatorAsClass != null) { indicatorAsClass = Primitives.unwrap(indicatorAsClass); if (Primitives.allPrimitiveTypes().contains(indicatorAsClass)) { return indicatorAsClass.getName(); } if (PATHNAME_CLASSES.contains(indicatorAsClass)) { return "pathname"; } } } return "string"; } CustomHelpFormatter(); }
|
@Test public void extractTypeIndicator() { testExtraction(spec -> spec.ofType(SomeEnum.class), "string", "enum type option"); testExtraction(spec -> spec.ofType(String.class), "string", "string type option"); testExtraction(spec -> spec.ofType(Integer.class), "int", "Integer type option"); testExtraction(spec -> spec.ofType(Long.class), "long", "Long type option"); testExtraction(spec -> spec.ofType(Byte.class), "byte", "Byte type option"); testExtraction(spec -> spec.withValuesConvertedBy(new CharacterValueConverter()), "char", "Character type option"); testExtraction(spec -> spec.ofType(File.class), "pathname", "File type option"); testExtraction(spec -> spec.withValuesConvertedBy(new PathValueConverter()), "pathname", "Path type option"); testExtraction(spec -> spec.ofType(Constructible.class), "string", "custom class with string constructor option"); }
|
Hars { static Base64ByteSource base64DecodingSource(String base64Data) { return Base64ByteSource.wrap(base64Data); } static boolean isBase64Encoded(String contentType, String text, @Nullable String harContentEncoding, @Nullable Long bodySize); @Nullable static ByteSource getRequestPostData(@Nullable List<NameValuePair> params, String contentType, String postDataText, @Nullable Long requestBodySize, @Nullable String postDataComment, Charset defaultCharset); static TypedContent translateResponseContent( String contentType,
@Nullable String text,
@Nullable Long bodySize,
@Nullable Long contentSize,
@Nullable String contentEncodingHeaderValue,
@Nullable String harContentEncoding,
@SuppressWarnings("unused") @Nullable String comment,
Charset defaultCharset); static HarHeader newHarHeader(String name, String value); }
|
@Test public void sizeOfBase64DecodedByteSourceIsKnown() throws Exception { byte[] bytes = "hello, world".getBytes(StandardCharsets.US_ASCII); String base64 = BaseEncoding.base64().encode(bytes); ByteSource decodingSource = Hars.base64DecodingSource(base64); Optional<Long> sizeIfKnown = decodingSource.sizeIfKnown().toJavaUtil(); System.out.format("%s size: %s%n", decodingSource, sizeIfKnown); assertTrue("size known", sizeIfKnown.isPresent()); assertEquals("size", bytes.length, sizeIfKnown.get().longValue()); }
|
Hars { public static TypedContent translateResponseContent( String contentType, @Nullable String text, @Nullable Long bodySize, @Nullable Long contentSize, @Nullable String contentEncodingHeaderValue, @Nullable String harContentEncoding, @SuppressWarnings("unused") @Nullable String comment, Charset defaultCharset) { return getUncompressedContent(contentType, text, bodySize, contentSize, contentEncodingHeaderValue, harContentEncoding, comment, defaultCharset); } static boolean isBase64Encoded(String contentType, String text, @Nullable String harContentEncoding, @Nullable Long bodySize); @Nullable static ByteSource getRequestPostData(@Nullable List<NameValuePair> params, String contentType, String postDataText, @Nullable Long requestBodySize, @Nullable String postDataComment, Charset defaultCharset); static TypedContent translateResponseContent( String contentType,
@Nullable String text,
@Nullable Long bodySize,
@Nullable Long contentSize,
@Nullable String contentEncodingHeaderValue,
@Nullable String harContentEncoding,
@SuppressWarnings("unused") @Nullable String comment,
Charset defaultCharset); static HarHeader newHarHeader(String name, String value); }
|
@Test public void complicatedTextEncodingIssue() throws Exception { String contentType = "text/javascript"; String harContentEncoding = null; String contentEncodingHeaderValue = "br"; String comment = ""; String text = "let nbsp=\"\u00A0\";"; byte[] expectedBytes = text.getBytes(UTF_8); String expectedBytesHex = BaseEncoding.base16().encode(expectedBytes); System.out.format("complicated text: \"%s\"%n", StringEscapeUtils.escapeJava(text)); System.out.format("%s decoded with %s is: %s%n", expectedBytesHex, UTF_8, new String(expectedBytes, UTF_8)); System.out.format("%s decoded with %s is: %s%n", expectedBytesHex, ISO_8859_1, new String(expectedBytes, ISO_8859_1)); long contentSize = expectedBytes.length; long bodySize = expectedBytes.length; @SuppressWarnings("UnnecessaryLocalVariable") Charset EX_MACHINA_CHARSET = UTF_8; @SuppressWarnings("ConstantConditions") TypedContent typedContent = Hars.translateResponseContent(contentType, text, bodySize, contentSize, contentEncodingHeaderValue, harContentEncoding, comment, EX_MACHINA_CHARSET); byte[] actualBytes = typedContent.asByteSource().read(); int actualSize = actualBytes.length; assertEquals("actual size", expectedBytes.length, actualSize); assertEquals("content-type charset", UTF_8, typedContent.getContentType().charset().orNull()); }
@Test public void testGzippedHtml() throws Exception { String json = Resources.toString(getClass().getResource("/gzipped-response.json"), UTF_8); JsonObject response = new JsonParser().parse(json).getAsJsonObject(); JsonObject content = response.getAsJsonObject("content"); String contentEncodingHeaderValue = HarBridgeTests.getFirstHeaderValueFromNameValuePairs(response.getAsJsonArray("headers"), HttpHeaders.CONTENT_ENCODING); String text = content.get("text").getAsString(); byte[] data = Hars.translateResponseContent(content.get("mimeType").getAsString(), text, response.get("bodySize").getAsLong(), content.get("size").getAsLong(), contentEncodingHeaderValue, null, null, UTF_8).asByteSource().read(); String decompressedText = new String(data, UTF_8); assertEquals("text", text, decompressedText); }
|
Hars { @Nullable public static ByteSource getRequestPostData(@Nullable List<NameValuePair> params, String contentType, String postDataText, @Nullable Long requestBodySize, @Nullable String postDataComment, Charset defaultCharset) throws IOException { if (params != null && !params.isEmpty()) { if (Strings.isNullOrEmpty(contentType)) { contentType = MediaType.FORM_DATA.toString(); } MediaType mediaType = MediaType.parse(contentType); return toByteSourceFromPairs(params, mediaType); } else { return translateRequestContent(contentType, postDataText, requestBodySize, null, postDataComment, defaultCharset); } } static boolean isBase64Encoded(String contentType, String text, @Nullable String harContentEncoding, @Nullable Long bodySize); @Nullable static ByteSource getRequestPostData(@Nullable List<NameValuePair> params, String contentType, String postDataText, @Nullable Long requestBodySize, @Nullable String postDataComment, Charset defaultCharset); static TypedContent translateResponseContent( String contentType,
@Nullable String text,
@Nullable Long bodySize,
@Nullable Long contentSize,
@Nullable String contentEncodingHeaderValue,
@Nullable String harContentEncoding,
@SuppressWarnings("unused") @Nullable String comment,
Charset defaultCharset); static HarHeader newHarHeader(String name, String value); }
|
@Test public void getRequestPostData() throws Exception { List<NameValuePair> pairs = new ArrayList<>(); String contentType = "multipart/mixed; boundary=ABCDEF_1522096137171"; String postDataText = "--ABCDEF_1522096137171\r\n" + "Content-Type: application/x-www-form-urlencoded\r\n" + "\r\n" + "foo=bar&baz=gaw\r\n" + "--ABCDEF_1522096137171--"; String postDataComment = ""; Long requestBodySize = 116L; ByteSource actual = Hars.getRequestPostData(pairs, contentType, postDataText, requestBodySize, postDataComment, UTF_8); assertNotNull("byte source not null is expected", actual); ByteSource expected = CharSource.wrap(postDataText).asByteSource(StandardCharsets.US_ASCII); assertEquals("bytes", BaseEncoding.base16().encode(expected.read()), BaseEncoding.base16().encode(actual.read())); }
|
ContentDisposition { public static ContentDisposition parse(String contentDisposition) { List<String> parts = tokenize(contentDisposition); String type = parts.get(0); String name = null; String filename = null; Charset charset = null; Long size = null; ZonedDateTime creationDate = null; ZonedDateTime modificationDate = null; ZonedDateTime readDate = null; for (int i = 1; i < parts.size(); i++) { String part = parts.get(i); int eqIndex = part.indexOf('='); if (eqIndex != -1) { String attribute = part.substring(0, eqIndex); String value = (part.startsWith("\"", eqIndex + 1) && part.endsWith("\"") ? part.substring(eqIndex + 2, part.length() - 1) : part.substring(eqIndex + 1, part.length())); if (attribute.equals("name") ) { name = value; } else if (attribute.equals("filename*") ) { filename = decodeHeaderFieldParam(value); charset = Charset.forName(value.substring(0, value.indexOf('\''))); checkArgument(UTF_8.equals(charset) || ISO_8859_1.equals(charset), "Charset should be UTF-8 or ISO-8859-1"); } else if (attribute.equals("filename") && (filename == null)) { filename = value; } else if (attribute.equals("size") ) { size = Long.parseLong(value); } else if (attribute.equals("creation-date")) { try { creationDate = ZonedDateTime.parse(value, RFC_1123_DATE_TIME); } catch (DateTimeParseException ex) { } } else if (attribute.equals("modification-date")) { try { modificationDate = ZonedDateTime.parse(value, RFC_1123_DATE_TIME); } catch (DateTimeParseException ex) { } } else if (attribute.equals("read-date")) { try { readDate = ZonedDateTime.parse(value, RFC_1123_DATE_TIME); } catch (DateTimeParseException ex) { } } } else { throw new IllegalArgumentException("Invalid content disposition format"); } } return new ContentDisposition(type, name, filename, charset, size, creationDate, modificationDate, readDate); } private ContentDisposition(@Nullable String type, @Nullable String name, @Nullable String filename,
@Nullable Charset charset, @Nullable Long size, @Nullable ZonedDateTime creationDate,
@Nullable ZonedDateTime modificationDate, @Nullable ZonedDateTime readDate); @Nullable String getType(); @Nullable String getName(); @Nullable String getFilename(); @Nullable Charset getCharset(); @Nullable Long getSize(); @Nullable ZonedDateTime getCreationDate(); @Nullable ZonedDateTime getModificationDate(); @Nullable ZonedDateTime getReadDate(); @Override boolean equals(Object other); @Override int hashCode(); @Override String toString(); static Builder builder(String type); static ContentDisposition empty(); static ContentDisposition parse(String contentDisposition); }
|
@Test public void parse() { String header = "form-data; name=\"f\"; filename=\"image-for-upload.jpeg\""; ContentDisposition d = ContentDisposition.parse(header); System.out.format("parsed: %s%n", d); assertEquals("type", "form-data", d.getType()); assertEquals("name", "f", d.getName()); assertEquals("filename", "image-for-upload.jpeg", d.getFilename()); }
|
HarResponseDataTransformer { public HarResponseDataTransformer replaceContentType(MediaType contentType) { return replaceHeader(HttpHeaders.CONTENT_TYPE, contentType.toString()) .contentType(old -> contentType); } HarResponseDataTransformer(HarResponseData preTransformData); HarResponseDataTransformer body(Function<ByteSource, ByteSource> bodyTransform); HarResponseDataTransformer contentType(Function<MediaType, MediaType> contentTypeSupplier); HarResponseDataTransformer headers(Function<Stream<Map.Entry<String, String>>, Stream<Map.Entry<String, String>>> headersTransform); HarResponseDataTransformer filterHeaders(Predicate<? super Map.Entry<String, String>> filter); HarResponseDataTransformer mapHeader(Function<Map.Entry<String, String>, Map.Entry<String, String>> map); HarResponseDataTransformer mapHeaderWithName(String headerName, Function<String, String> valueMap); HarResponseDataTransformer replaceHeader(String headerName, String newValue); HarResponseDataTransformer replaceContentType(MediaType contentType); HarResponseData transform(); }
|
@Test public void replaceContentType() { MediaType originalContentType = MediaType.parse("text/plain"); Iterable<Map.Entry<String, String>> originalHeaders = Collections.singleton(new AbstractMap.SimpleImmutableEntry<>(HttpHeaders.CONTENT_TYPE, originalContentType.toString())); HarResponseData responseData = HarResponseData.of(originalHeaders, originalContentType, null); MediaType newContentType = originalContentType.withCharset(UTF_8); HarResponseData transformed = responseData.transformer() .replaceContentType(newContentType) .transform(); assertEquals("contentType getter", newContentType, transformed.getContentType()); String actualNewContentTypeHeaderValue = transformed.getFirstHeaderValue(HttpHeaders.CONTENT_TYPE); assertNotNull("expect header value present", actualNewContentTypeHeaderValue); assertEquals("header value parsed", newContentType, MediaType.parse(actualNewContentTypeHeaderValue)); }
|
HarResponseDataTransformer { public HarResponseDataTransformer filterHeaders(Predicate<? super Map.Entry<String, String>> filter) { return headers(stream -> stream.filter(filter)); } HarResponseDataTransformer(HarResponseData preTransformData); HarResponseDataTransformer body(Function<ByteSource, ByteSource> bodyTransform); HarResponseDataTransformer contentType(Function<MediaType, MediaType> contentTypeSupplier); HarResponseDataTransformer headers(Function<Stream<Map.Entry<String, String>>, Stream<Map.Entry<String, String>>> headersTransform); HarResponseDataTransformer filterHeaders(Predicate<? super Map.Entry<String, String>> filter); HarResponseDataTransformer mapHeader(Function<Map.Entry<String, String>, Map.Entry<String, String>> map); HarResponseDataTransformer mapHeaderWithName(String headerName, Function<String, String> valueMap); HarResponseDataTransformer replaceHeader(String headerName, String newValue); HarResponseDataTransformer replaceContentType(MediaType contentType); HarResponseData transform(); }
|
@Test public void filterHeaders() throws Exception { Iterable<Map.Entry<String, String>> originalHeaders = ImmutableMap.<String, String>builder() .put("a", "1") .put("b", "2") .put("c", "3") .build().entrySet(); HarResponseData responseData = HarResponseData.of(originalHeaders, null, null); HarResponseData transformed = responseData.transformer() .filterHeaders(header -> !"b".equalsIgnoreCase(header.getKey())) .transform(); assertEquals("a", "1", transformed.getFirstHeaderValue("a")); assertEquals("c", "3", transformed.getFirstHeaderValue("c")); assertNull("b", transformed.getFirstHeaderValue("b")); }
|
Base64ByteSource extends ByteSource { @Override public long size() { return decodedLength; } protected Base64ByteSource(String base64Data); @Override InputStream openStream(); @Override boolean isEmpty(); @SuppressWarnings("Guava") @Override com.google.common.base.Optional<Long> sizeIfKnown(); @Override long size(); static Base64ByteSource wrap(String base64Data); }
|
@Test public void size() throws Exception { for (int n = 0; n < 16; n++) { byte[] bytes = new byte[n]; String base64Data = BaseEncoding.base64().encode(bytes); ByteSource decodingSource = Base64ByteSource.wrap(base64Data); assertEquals(String.format("base64 length %d", base64Data.length()), n, decodingSource.size()); } }
|
SstoehrHarBridge implements HarBridge<HarEntry> { @Override public String getRequestMethod(HarEntry entry) { HarRequest request = entry.getRequest(); if (request != null) { HttpMethod method = request.getMethod(); if (method != null) { return method.name(); } } log.info("request method not present in HAR entry"); return ""; } SstoehrHarBridge(); SstoehrHarBridge(Charset exMachinaCharset); @Override String getRequestMethod(HarEntry entry); @Override String getRequestUrl(HarEntry entry); @Override Stream<Map.Entry<String, String>> getRequestHeaders(HarEntry entry); @Nullable @Override ByteSource getRequestPostData(HarEntry entry); @Override HarResponseData getResponseData(ParsedRequest request, HarEntry entry, HarResponseEncoding encoding); @Override int getResponseStatus(HarEntry entry); static final Charset DEFAULT_EX_MACHINA_CHARSET; }
|
@Test public void getRequestMethod() throws Exception { assertEquals("method", HttpMethod.GET.name(), bridge.getRequestMethod(entry)); }
|
SstoehrHarBridge implements HarBridge<HarEntry> { @Override public String getRequestUrl(HarEntry entry) { String url = null; HarRequest request = entry.getRequest(); if (request != null) { url = request.getUrl(); } if (url == null) { log.info("request URL not present in HAR entry"); url = ""; } return url; } SstoehrHarBridge(); SstoehrHarBridge(Charset exMachinaCharset); @Override String getRequestMethod(HarEntry entry); @Override String getRequestUrl(HarEntry entry); @Override Stream<Map.Entry<String, String>> getRequestHeaders(HarEntry entry); @Nullable @Override ByteSource getRequestPostData(HarEntry entry); @Override HarResponseData getResponseData(ParsedRequest request, HarEntry entry, HarResponseEncoding encoding); @Override int getResponseStatus(HarEntry entry); static final Charset DEFAULT_EX_MACHINA_CHARSET; }
|
@Test public void getRequestUrl() throws Exception { assertEquals("url", url.toString(), bridge.getRequestUrl(entry)); }
|
SstoehrHarBridge implements HarBridge<HarEntry> { @Override public Stream<Map.Entry<String, String>> getRequestHeaders(HarEntry entry) { HarRequest request = entry.getRequest(); if (request != null) { List<HarHeader> headers = request.getHeaders(); if (headers != null) { return headers.stream() .map(header -> new SimpleImmutableEntry<>(header.getName(), header.getValue())); } } return Stream.empty(); } SstoehrHarBridge(); SstoehrHarBridge(Charset exMachinaCharset); @Override String getRequestMethod(HarEntry entry); @Override String getRequestUrl(HarEntry entry); @Override Stream<Map.Entry<String, String>> getRequestHeaders(HarEntry entry); @Nullable @Override ByteSource getRequestPostData(HarEntry entry); @Override HarResponseData getResponseData(ParsedRequest request, HarEntry entry, HarResponseEncoding encoding); @Override int getResponseStatus(HarEntry entry); static final Charset DEFAULT_EX_MACHINA_CHARSET; }
|
@Test public void getRequestHeaders() throws Exception { assertEquals("request header count", 0L, bridge.getRequestHeaders(entry).count()); }
|
HarReplayMain { int main0(String[] args) throws IOException { try { OptionSet optionSet = parser.parse(args); if (optionSet.has(OPT_HELP)) { parser.printHelpOn(System.out); return 0; } if (optionSet.has(OPT_VERSION)) { printVersion(System.out); return 0; } operate(optionSet); } catch (UsageException | joptsimple.OptionException e) { System.err.format("har-replay: %s%n", e.getMessage()); System.err.format("har-replay: use --help to print options%n"); return 1; } return 0; } HarReplayMain(); @VisibleForTesting HarReplayMain(OptionParser parser); static void main(String[] args); }
|
@Test public void main0() throws Exception { assertEquals("exit code", 1, new NonSleepingHarReplayMain().main0(new String[]{})); }
@Test public void readBrowsermobGeneratedFile() throws Exception { File harFile = getBrowsermobGeneratedHarFile(); HarReplayMain main = new NonSleepingHarReplayMain(); int exitCode = main.main0(new String[]{harFile.getAbsolutePath()}); assertEquals("exit code", 0, exitCode); }
@Test public void readBrowsermobGeneratedFile_failBecauseStockHarBehavior() throws Exception { File harFile = getBrowsermobGeneratedHarFile(); HarReplayMain main = new NonSleepingHarReplayMain(); try { main.main0(new String[]{ harFile.getAbsolutePath(), "--har-reader-behavior", HarReaderBehavior.STOCK.name() }); fail("exception should be thrown here"); } catch (Exception e) { List<Throwable> causes = ImmutableList.copyOf(Throwables.getCausalChain(e)); boolean hasInvalidFormatEx = causes.stream().anyMatch(com.fasterxml.jackson.databind.exc.InvalidFormatException.class::isInstance); assertTrue("expected exception not found in cause chain: " + causes, hasInvalidFormatEx); } }
|
SstoehrHarBridge implements HarBridge<HarEntry> { @Override public HarResponseData getResponseData(ParsedRequest request, HarEntry entry, HarResponseEncoding encoding) throws IOException { TypedContent contentPackage = getResponseBody(entry); List<Map.Entry<String, String>> headers = getResponseHeaders(entry); HarResponseData underlying = HarResponseData.of(headers, contentPackage.getContentType(), contentPackage.asByteSource()); underlying = underlying.transformer() .replaceContentType(contentPackage.getContentType()) .replaceHeader(HttpHeaders.CONTENT_ENCODING, HttpContentCodecs.CONTENT_ENCODING_IDENTITY) .transform(); return encoding.transformUnencoded(underlying); } SstoehrHarBridge(); SstoehrHarBridge(Charset exMachinaCharset); @Override String getRequestMethod(HarEntry entry); @Override String getRequestUrl(HarEntry entry); @Override Stream<Map.Entry<String, String>> getRequestHeaders(HarEntry entry); @Nullable @Override ByteSource getRequestPostData(HarEntry entry); @Override HarResponseData getResponseData(ParsedRequest request, HarEntry entry, HarResponseEncoding encoding); @Override int getResponseStatus(HarEntry entry); static final Charset DEFAULT_EX_MACHINA_CHARSET; }
|
@Test public void getResponseData() throws Exception { ParsedRequest request = ParsedRequest.inMemory(io.github.mike10004.vhs.harbridge.HttpMethod.GET, URI.create("http: HarResponseData responseData = bridge.getResponseData(request, entry, HarResponseEncoding.unencoded()); assertEquals("body size", responseBody.length, responseData.getBody().size()); assertEquals("content type", contentType, responseData.getContentType()); assertEquals("number of headers", entry.getResponse().getHeaders().size(), (responseData.headers()).size()); }
@Test public void getContentType_absent() throws Exception { HarBridge<HarEntry> bridge = new SstoehrHarBridge(); HarEntry entry = new HarEntry(); HarResponse response = new HarResponse(); HarContent content = new HarContent(); response.setContent(content); entry.setResponse(response); ParsedRequest request = ParsedRequest.inMemory(io.github.mike10004.vhs.harbridge.HttpMethod.GET, URI.create("https: HarResponseData actual = bridge.getResponseData(request, entry, HarResponseEncoding.unencoded()); assertEquals("body", 0, actual.getBody().read().length); assertEquals("content-type", HarBridge.getContentTypeDefaultValue(), actual.getContentType()); assertEquals("", 0, actual.headers().size()); }
@Test public void getResponseData_contentTypeExMachina() throws Exception { Charset exMachinaCharset = UTF_8; SstoehrHarBridge bridge = new SstoehrHarBridge(exMachinaCharset); ParsedRequest request = ParsedRequest.inMemory(io.github.mike10004.vhs.harbridge.HttpMethod.GET, URI.create("http: MediaType entryResponseContentType = MediaType.PLAIN_TEXT_UTF_8.withoutParameters(); HarEntry entry = createHarEntry(request.url, entryResponseContentType, "foo", 3); HarResponseData responseData = bridge.getResponseData(request, entry, HarResponseEncoding.unencoded()); MediaType expectedResponseContentType = entryResponseContentType.withCharset(exMachinaCharset); MediaType responseDataContentType = responseData.getContentType(); assertEquals("responseDataContentType", expectedResponseContentType, responseDataContentType); String responseDataContentTypeHeaderValue = responseData.getFirstHeaderValue(HttpHeaders.CONTENT_TYPE); assertNotNull("expect responseData to contain content-type header", responseDataContentTypeHeaderValue); assertEquals("responseData content-type header value", expectedResponseContentType, MediaType.parse(responseDataContentTypeHeaderValue)); }
|
SstoehrHarBridge implements HarBridge<HarEntry> { @Nullable @Override public ByteSource getRequestPostData(HarEntry entry) throws IOException { HarRequest request = entry.getRequest(); if (request != null) { HarPostData postData = request.getPostData(); if (postData != null) { List<HarPostDataParam> params = postData.getParams(); List<NameValuePair> pairs = null; if (params != null) { pairs = params.stream().map(p -> NameValuePair.of(p.getName(), p.getValue())).collect(Collectors.toList()); } String contentType = postData.getMimeType(); String postDataText = postData.getText(); @Nullable Long requestBodySize = nullIfNegative(request.getBodySize()); @Nullable String postDataComment = postData.getComment(); return Hars.getRequestPostData(pairs, contentType, postDataText, requestBodySize, postDataComment, exMachinaCharset); } } return null; } SstoehrHarBridge(); SstoehrHarBridge(Charset exMachinaCharset); @Override String getRequestMethod(HarEntry entry); @Override String getRequestUrl(HarEntry entry); @Override Stream<Map.Entry<String, String>> getRequestHeaders(HarEntry entry); @Nullable @Override ByteSource getRequestPostData(HarEntry entry); @Override HarResponseData getResponseData(ParsedRequest request, HarEntry entry, HarResponseEncoding encoding); @Override int getResponseStatus(HarEntry entry); static final Charset DEFAULT_EX_MACHINA_CHARSET; }
|
@Test public void getRequestPostData() throws Exception { assertTrue(ByteSource.empty().contentEquals(bridge.getRequestPostData(entry))); }
@Test public void getRequestPostData_params() throws Exception { String json = "{\n" + " \"method\": \"POST\",\n" + " \"url\": \"https: " \"httpVersion\": \"HTTP/1.1\",\n" + " \"headers\": [\n" + " {\n" + " \"name\": \"Host\",\n" + " \"value\": \"www.example.com\"\n" + " },\n" + " {\n" + " \"name\": \"Connection\",\n" + " \"value\": \"keep-alive\"\n" + " },\n" + " {\n" + " \"name\": \"User-Agent\",\n" + " \"value\": \"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/56.0.2924.87 Safari/537.36\"\n" + " },\n" + " {\n" + " \"name\": \"content-type\",\n" + " \"value\": \"application/x-www-form-urlencoded;charset\\u003dUTF-8\"\n" + " }\n" + " ],\n" + " \"queryString\": [\n" + " {\n" + " \"name\": \"csrfToken\",\n" + " \"value\": \"ajax:123456789034567890\"\n" + " }\n" + " ],\n" + " \"postData\": {\n" + " \"mimeType\": \"application/x-www-form-urlencoded;charset\\u003dUTF-8\",\n" + " \"params\": [\n" + " {\n" + " \"name\": \"plist\",\n" + " \"value\": \"eeny/meeny/miny/mo\",\n" + " \"comment\": \"\"\n" + " }\n" + " ],\n" + " \"comment\": \"\"\n" + " },\n" + " \"headersSize\": 993,\n" + " \"bodySize\": 1996,\n" + " \"comment\": \"\"\n" + "}"; HarEntry harEntry = new HarEntry(); HarRequest request = new Gson().fromJson(json, HarRequest.class); harEntry.setRequest(request); ByteSource postData = new SstoehrHarBridge().getRequestPostData(harEntry); assertNotNull("post data", postData); HttpEntity entity = makeEntity(postData, MediaType.FORM_DATA.withCharset(UTF_8)); List<NameValuePair> params = URLEncodedUtils.parse(entity); assertEquals("num params", 1, params.size()); NameValuePair param = params.iterator().next(); assertEquals("name", "plist", param.getName()); assertEquals("value", "eeny/meeny/miny/mo", param.getValue()); }
@Test public void getRequestData() throws Exception { String requestJson = "{\n" + " \"method\": \"POST\",\n" + " \"url\": \"https: " \"httpVersion\": \"HTTP/1.1\",\n" + " \"cookies\": [],\n" + " \"headers\": [\n" + " {\n" + " \"name\": \"Host\",\n" + " \"value\": \"www.example.com\"\n" + " },\n" + " {\n" + " \"name\": \"Connection\",\n" + " \"value\": \"keep-alive\"\n" + " },\n" + " {\n" + " \"name\": \"Content-Length\",\n" + " \"value\": \"116\"\n" + " },\n" + " {\n" + " \"name\": \"X-ABCDEF-Protocol-Version\",\n" + " \"value\": \"Foo\"\n" + " },\n" + " {\n" + " \"name\": \"User-Agent\",\n" + " \"value\": \"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/56.0 Safari/537.36\"\n" + " },\n" + " {\n" + " \"name\": \"Content-Type\",\n" + " \"value\": \"multipart/mixed; boundary\\u003dABCDEF_1522096137171\"\n" + " },\n" + " {\n" + " \"name\": \"Accept\",\n" + " \"value\": \"application/json, text/javascript, */*; q\\u003d0.01\"\n" + " },\n" + " {\n" + " \"name\": \"X-Requested-With\",\n" + " \"value\": \"XMLHttpRequest\"\n" + " },\n" + " {\n" + " \"name\": \"Accept-Encoding\",\n" + " \"value\": \"gzip, deflate, br\"\n" + " },\n" + " {\n" + " \"name\": \"Accept-Language\",\n" + " \"value\": \"en-US,en;q\\u003d0.9\"\n" + " }\n" + " ],\n" + " \"queryString\": [],\n" + " \"postData\": {\n" + " \"mimeType\": \"multipart/mixed; boundary\\u003dABCDEF_1522096137171\",\n" + " \"params\": [],\n" + " \"text\": \"--ABCDEF_1522096137171\\r\\nContent-Type: application/x-www-form-urlencoded\\r\\n\\r\\nfoo\\u003dbar\\u0026baz\\u003dgaw\\r\\n--ABCDEF_1522096137171--\",\n" + " \"comment\": \"\"\n" + " },\n" + " \"headersSize\": 1891,\n" + " \"bodySize\": 116,\n" + " \"comment\": \"\"\n" + "}"; SstoehrHarBridge bridge = new SstoehrHarBridge(); HarRequest request = new Gson().fromJson(requestJson, HarRequest.class); HarEntry entry = new HarEntry(); entry.setRequest(request); ByteSource byteSource = bridge.getRequestPostData(entry); assertNotNull("post data byte source", byteSource); byte[] expected = request.getPostData().getText().getBytes(StandardCharsets.US_ASCII); assertEquals("post data bytes", BaseEncoding.base16().encode(expected), BaseEncoding.base16().encode(byteSource.read())); }
|
SstoehrHarBridge implements HarBridge<HarEntry> { @Override public int getResponseStatus(HarEntry entry) { HarResponse response = entry.getResponse(); if (response != null) { return response.getStatus(); } log.info("response not present in entry; returning 500 as status"); return 500; } SstoehrHarBridge(); SstoehrHarBridge(Charset exMachinaCharset); @Override String getRequestMethod(HarEntry entry); @Override String getRequestUrl(HarEntry entry); @Override Stream<Map.Entry<String, String>> getRequestHeaders(HarEntry entry); @Nullable @Override ByteSource getRequestPostData(HarEntry entry); @Override HarResponseData getResponseData(ParsedRequest request, HarEntry entry, HarResponseEncoding encoding); @Override int getResponseStatus(HarEntry entry); static final Charset DEFAULT_EX_MACHINA_CHARSET; }
|
@Test public void getResponseStatus() throws Exception { assertEquals(200, bridge.getResponseStatus(entry)); }
|
SstoehrHarBridge implements HarBridge<HarEntry> { @VisibleForTesting TypedContent getResponseBody(HarEntry entry) throws IOException { HarResponse rsp = entry.getResponse(); if (rsp == null) { return TypedContent.identity(ByteSource.empty(), MediaType.OCTET_STREAM); } HarContent content = requireNonNull(rsp.getContent(), "response.content"); @Nullable Long harContentSize = nullIfNegative(content.getSize()); @Nullable Long bodySize = nullIfNegative(rsp.getBodySize()); List<HarHeader> headers = MoreObjects.firstNonNull(rsp.getHeaders(), Collections.emptyList()); @Nullable String contentEncodingHeaderValue = headers.stream() .filter(h -> HttpHeaders.CONTENT_ENCODING.equalsIgnoreCase(h.getName())) .map(HarHeader::getValue) .findFirst().orElse(null); @Nullable String harContentEncoding = Strings.emptyToNull(content.getEncoding()); @Nullable String contentType = content.getMimeType(); @Nullable String comment = content.getComment(); @Nullable String text = content.getText(); return Hars.translateResponseContent(contentType, text, bodySize, harContentSize, contentEncodingHeaderValue, harContentEncoding, comment, exMachinaCharset); } SstoehrHarBridge(); SstoehrHarBridge(Charset exMachinaCharset); @Override String getRequestMethod(HarEntry entry); @Override String getRequestUrl(HarEntry entry); @Override Stream<Map.Entry<String, String>> getRequestHeaders(HarEntry entry); @Nullable @Override ByteSource getRequestPostData(HarEntry entry); @Override HarResponseData getResponseData(ParsedRequest request, HarEntry entry, HarResponseEncoding encoding); @Override int getResponseStatus(HarEntry entry); static final Charset DEFAULT_EX_MACHINA_CHARSET; }
|
@Test public void getResponseBody_addExMachinaCharsetToContentTypeHeader() throws Exception { Charset exMachinaCharset = UTF_8; SstoehrHarBridge bridge = new SstoehrHarBridge(exMachinaCharset); ParsedRequest request = ParsedRequest.inMemory(io.github.mike10004.vhs.harbridge.HttpMethod.GET, URI.create("http: MediaType entryResponseContentType = MediaType.PLAIN_TEXT_UTF_8.withoutParameters(); HarEntry entry = createHarEntry(request.url, entryResponseContentType, "foo", 3); TypedContent content = bridge.getResponseBody(entry); MediaType expectedResponseContentType = entryResponseContentType.withCharset(exMachinaCharset); assertEquals("content type", expectedResponseContentType, content.getContentType()); }
|
ContentTypes { public static boolean isTextLike(@Nullable String contentType) { if (contentType == null) { return false; } MediaType mime = null; try { mime = MediaType.parse(contentType).withoutParameters(); } catch (IllegalArgumentException e) { log.debug("failed to parse mime type from {}", contentType); } if (mime != null) { if (mime.is(MediaType.ANY_TEXT_TYPE)) { return true; } if (isSubtypeXmlish(mime)) { return true; } if (isSubtypeJsonish(mime)) { return true; } if (TEXT_LIKE_TYPES.contains(mime)) { return true; } } return false; } private ContentTypes(); static boolean isTextLike(@Nullable String contentType); }
|
@Test public void isTextLike() { boolean actual = ContentTypes.isTextLike(testCase.contentType); String message = String.format("expect text-like %s for \"%s\"", testCase.expected, StringEscapeUtils.escapeJava(testCase.contentType)); System.out.format("%s; actual = %s%n", message, actual); assertEquals(message, testCase.expected, actual); try { if (testCase.contentType != null) { boolean actualWithoutParams = ContentTypes.isTextLike(MediaType.parse(testCase.contentType).toString()); assertEquals(message + " without parameters", testCase.expected, actualWithoutParams); } } catch (IllegalArgumentException ignore) { } }
|
StatefulHeuristicEntryMatcher extends HeuristicEntryMatcher<ReplaySessionState> { public static EntryMatcherFactory<ReplaySessionState> factory(Heuristic heuristic, int thresholdExclusive) { return new MyFactory(heuristic, thresholdExclusive); } StatefulHeuristicEntryMatcher(Heuristic heuristic, int thresholdExclusive, Collection<ParsedEntry> entries); static EntryMatcherFactory<ReplaySessionState> factory(Heuristic heuristic, int thresholdExclusive); }
|
@Test public void stateful() throws Exception { EntryMatcherFactory<ReplaySessionState> factory = StatefulHeuristicEntryMatcher.factory(new BasicHeuristic(), BasicHeuristic.DEFAULT_THRESHOLD_EXCLUSIVE); List<String> responses = testEntryMatcher(factory); assertEquals("responses", Arrays.asList("first", "second", "first"), responses); }
@Test public void stateless() throws Exception { EntryMatcherFactory<ReplaySessionState> factory = HeuristicEntryMatcher.factory(new BasicHeuristic(), BasicHeuristic.DEFAULT_THRESHOLD_EXCLUSIVE); List<String> responses = testEntryMatcher(factory); assertEquals("responses", Arrays.asList("first", "first", "first"), responses); }
|
HttpRequests { @Nullable public static Multimap<String, Optional<String>> parseQuery(URI uri) { if (uri.getQuery() == null) { return null; } List<Entry<String, String>> nvps = URLEncodedUtils.parse(uri, StandardCharsets.UTF_8); Multimap<String, Optional<String>> mm = ArrayListMultimap.create(); nvps.forEach(nvp -> { mm.put(nvp.getKey().toLowerCase(), Optional.ofNullable(nvp.getValue())); }); return mm; } private HttpRequests(); static Multimap<String, V> indexHeaders(Stream<? extends Map.Entry<String, V>> entryHeaders); @Nullable static Multimap<String, Optional<String>> parseQuery(URI uri); }
|
@Test public void parseQuery() { Multimap<String, Optional<String>> q = HttpRequests.parseQuery(URI.create("http: assertNull(q); q = HttpRequests.parseQuery(URI.create("http: assertEquals(ImmutableMultimap.of("foo", Optional.of("bar")), q); q = HttpRequests.parseQuery(URI.create("http: assertEquals(ImmutableMultimap.of(), q); }
@Test public void parseQuery_paramWithNoAssignment() { URI uri = URI.create("https: Multimap<?, ?> query = HttpRequests.parseQuery(uri); assertNotNull(query); ImmutableMultimap.copyOf(query); }
@Test public void parseQuery_paramWithEmptyNameIsIgnored() { URI uri = URI.create("https: Multimap<String, Optional<String>> query = HttpRequests.parseQuery(uri); assertNotNull("query is null but shouldn't be", query); ImmutableMultimap.copyOf(query); assertEquals("bar", ImmutableList.of(Optional.of("baz")), ImmutableList.copyOf(query.get("bar"))); assertEquals("<empty>", ImmutableList.of(), ImmutableList.copyOf(query.get(""))); }
|
NameValuePairImpl implements NameValuePair { @Override public boolean equals(Object o) { if (this == o) return true; if (o == null || !NameValuePair.class.isAssignableFrom(o.getClass())) return false; NameValuePair that = (NameValuePair) o; return Objects.equals(name, that.getName()) && Objects.equals(value, that.getValue()); } NameValuePairImpl(String name, String value); @Override String getName(); @Override String getValue(); @Override boolean equals(Object o); @Override int hashCode(); @Override String toString(); }
|
@Test public void equals() { assertEquals("same", NameValuePair.of("x", "y"), NameValuePair.of("x", "y")); }
|
URLEncodedUtils { public static List<Entry<String, String>> parse(final URI uri, final Charset charset) { requireNonNull(uri, "URI"); final String query = uri.getRawQuery(); if (query != null && !query.isEmpty()) { return parse(query, charset); } return Collections.emptyList(); } private URLEncodedUtils(); static List<Entry<String, String>> parse(final URI uri, final Charset charset); static List<Map.Entry<String, String>> parse(final String s, final Charset charset); static List<Map.Entry<String, String>> parse(
final CharArrayBuffer buf, final Charset charset, final char... separators); static List<NameValuePair> parseToNameValuePairs(String query, Charset charset); static String encodeFormFields(final String content, final Charset charset); static String format(
final Iterable<? extends NameValuePair> parameters,
final Charset charset); static String format(
final Iterable<? extends NameValuePair> parameters,
final char parameterSeparator,
final Charset charset); }
|
@Test public void parse_string() { String s = "foo=bar"; java.util.Map.Entry<String, String> pair = URLEncodedUtils.parse(s, StandardCharsets.UTF_8).iterator().next(); assertEquals("value of param definition " + s, new SimpleImmutableEntry<>("foo", "bar"), pair); }
|
NanohttpdTlsEndpointFactory implements TlsEndpointFactory { @SuppressWarnings("RedundantThrows") public static TrustSource createTrustSource(KeystoreData keystoreData) throws IOException, GeneralSecurityException { return TrustSource.defaultTrustSource() .add(keystoreData.asCertificateAndKeySource().load().getCertificate()); } NanohttpdTlsEndpointFactory(SSLServerSocketFactory socketFactory, TrustSource trustSource, @Nullable Integer port); @Override TlsEndpoint produce(BrowsermobVhsConfig config, Path scratchDir); static NanohttpdTlsEndpointFactory create(KeystoreData keystoreData, @Nullable Integer port); static SSLServerSocketFactory createSSLServerSocketFactory(KeystoreData keystoreData); @SuppressWarnings("RedundantThrows") static TrustSource createTrustSource(KeystoreData keystoreData); }
|
@Test public void createTrustSource() throws Exception { KeystoreData keystoreData = BmpTests.generateKeystoreForUnitTest(null); TrustSource trustSource = NanohttpdTlsEndpointFactory.createTrustSource(keystoreData); assertNotNull("trustSource", trustSource); int numTrustedCAs = trustSource.getTrustedCAs().length; assertTrue("more than one trusted CA", numTrustedCAs > 1); }
|
RequestCapture { public static RequestCapture of(HttpVersion httpVersion, ParsedRequest fullCapturedRequest) { return new RequestCapture(httpVersion, fullCapturedRequest); } private RequestCapture(HttpVersion httpVersion, ParsedRequest request); static RequestCapture of(HttpVersion httpVersion, ParsedRequest fullCapturedRequest); final HttpVersion httpVersion; final ParsedRequest request; }
|
@Test public void queryStringToMultimapOfOptionals() { URI urlWithNoQuery = URI.create("http: assertNull("no query", RequestAccumulator.queryStringToMultimapOfOptionals(urlWithNoQuery)); URI urlWithEmptyQuery = URI.create("http: assertEquals("empty query", ImmutableMultimap.of(), RequestAccumulator.queryStringToMultimapOfOptionals(urlWithEmptyQuery)); URI urlWithQuery = URI.create("http: assertEquals("url with query", ImmutableMultimap.of("foo", Optional.of("bar")), RequestAccumulator.queryStringToMultimapOfOptionals(urlWithQuery)); URI urlWithValuelessParam = URI.create("http: assertEquals("url with query", ImmutableMultimap.of("foo", Optional.empty()), RequestAccumulator.queryStringToMultimapOfOptionals(urlWithValuelessParam)); URI urlWithEmptyValuedParam = URI.create("http: assertEquals("url with query", ImmutableMultimap.of("foo", Optional.of("")), RequestAccumulator.queryStringToMultimapOfOptionals(urlWithEmptyValuedParam)); }
|
BrowsermobVirtualHarServer implements VirtualHarServer { @Override public VirtualHarServerControl start() throws IOException { List<Closeable> closeables = new ArrayList<>(); Scratch scratch = config.scratchDirProvider.createScratchDir(); closeables.add(scratch); CertificateAndKeySource certificateAndKeySource; BrowserUpProxy proxy; Path scratchPath = scratch.getRoot(); try { certificateAndKeySource = config.certificateAndKeySourceFactory.produce(config, scratchPath); TlsEndpoint httpsInterceptionServer = config.tlsEndpointFactory.produce(config, scratchPath); closeables.add(httpsInterceptionServer); TrustSource trustSource = httpsInterceptionServer.getTrustSource(); proxy = startProxy(config.bmpResponseManufacturer.withFreshState(), httpsInterceptionServer.getSocketAddress(), certificateAndKeySource, trustSource); } catch (RuntimeException | IOException e) { closeAll(closeables, true); throw e; } return new BrowsermobVhsControl(proxy, closeables); } BrowsermobVirtualHarServer(BrowsermobVhsConfig config); @Override VirtualHarServerControl start(); }
|
@Test public void https_rejectUpstreamBadCertificate() throws Exception { System.out.println("https_rejectUpstreamBadCertificate"); System.out.println("expect some big exception stack traces in the logs for this one"); Path temporaryDirectory = temporaryFolder.newFolder().toPath(); File harFile = VhsTests.getHttpsExampleHarFile(temporaryDirectory); EntryMatcherFactory entryMatcherFactory = HeuristicEntryMatcher.factory(new BasicHeuristic(), BasicHeuristic.DEFAULT_THRESHOLD_EXCLUSIVE); int port = VhsTests.findOpenPort(); TestContext context = new TestContext() .put(KEY_TLS_MODE, TlsMode.SUPPORT_REQUIRED) .put(KEY_CLIENT_SUPPLIER, BlindlyTrustingClient.supplier()); BrowsermobVhsConfig config = createServerConfig(port, harFile, entryMatcherFactory, context); URI goodUrl = URI.create("https: List<URI> urls = Arrays.asList(goodUrl, selfSignedUrl); PassthruPredicate passthruPredicate = new PassthruPredicate() { @Override public boolean isForwardable(HttpRequest originalRequest, @Nullable ChannelHandlerContext ctx) { String host = getHost(originalRequest); return urls.stream().map(URI::getHost).anyMatch(host::equals); } }; VirtualHarServer server = new BrowsermobVirtualHarServer(config) { @Override protected PassthruPredicate createPassthruPredicate() { return passthruPredicate; } }; Multimap<URI, ResponseSummary> responses; try (VirtualHarServerControl ctrl = server.start()) { Supplier<ApacheRecordingClient> clientFactory = context.get(KEY_CLIENT_SUPPLIER); ApacheRecordingClient client = clientFactory.get(); responses = client.collectResponses(urls, ctrl.getSocketAddress()); } assertEquals("expect 1 response per URL in " + urls, urls.size(), responses.size()); assertTrue("all URLs represented in response map", responses.keySet().containsAll(urls)); ResponseSummary badSslResponse = responses.get(selfSignedUrl).iterator().next(); assertEquals("status " + badSslResponse.statusLine, HttpStatus.SC_BAD_GATEWAY, badSslResponse.statusLine.getStatusCode()); ResponseSummary goodResponse = responses.get(goodUrl).iterator().next(); assertEquals("status from good URL response", HttpStatus.SC_OK, goodResponse.statusLine.getStatusCode()); }
@Test public void unspecifiedEncoding() throws Exception { String HEX_BYTES = "E29C93"; byte[] bytes = BaseEncoding.base16().decode(HEX_BYTES); String text = new String(bytes, StandardCharsets.UTF_8); System.out.format("text: %s%n", text); String url = "http: HarRequest request = BmpTests.buildHarRequest(HttpMethod.GET, url, ImmutableList.of()); MediaType contentType = MediaType.PLAIN_TEXT_UTF_8.withoutParameters(); System.out.format("content-type: %s%n", contentType); HarContent responseContent = BmpTests.buildHarContent(text, contentType); List<HarHeader> responseHeaders = BmpTests.buildHarHeaders(HttpHeaders.CONTENT_TYPE, contentType.toString()); HarResponse response = BmpTests.buildHarResponse(200, responseHeaders, responseContent); HarEntry entry = BmpTests.buildHarEntry(request, response); List<HarEntry> entries = ImmutableList.of(entry); BmpResponseManufacturer responseManufacturer = BmpTests.createManufacturer(entries, Collections.emptyList()); BrowsermobVhsConfig config = BrowsermobVhsConfig.builder(responseManufacturer) .scratchDirProvider(ScratchDirProvider.under(temporaryFolder.getRoot().toPath())) .responseListener(newLoggingResponseListener()) .build(); VirtualHarServer server = new BrowsermobVirtualHarServer(config); Multimap<URI, byte[]> responses; try (VirtualHarServerControl ctrl = server.start()) { ApacheRawClient<byte[]> client = new ApacheRawClient<byte[]>() { @Override protected byte[] transform(URI requestUrl, org.apache.http.HttpResponse response) throws IOException { return EntityUtils.toByteArray(response.getEntity()); } }; responses = client.collectResponses(Collections.singleton(URI.create(url)), ctrl.getSocketAddress()); } assertEquals("num responses", 1, responses.size()); byte[] actual = responses.values().iterator().next(); System.out.format("expecting %s, actual = %s%n", HEX_BYTES, BaseEncoding.base16().encode(actual)); assertArrayEquals("response data", bytes, actual); }
|
JreKeystoreGenerator implements KeystoreGenerator { @VisibleForTesting static char[] asciiBytesToChars(byte[] asciiBytes) { char[] chars = new char[asciiBytes.length]; for (int i = 0; i < chars.length; i++) { checkArgument(asciiBytes[i] >= 0 && asciiBytes[i] < 128, "char at index %s is not ascii: %s", i, asciiBytes[i]); chars[i] = (char) asciiBytes[i]; } return chars; } JreKeystoreGenerator(KeystoreType keystoreType, Random random); JreKeystoreGenerator(KeystoreType keystoreType); @Override KeystoreData generate(); KeystoreData generate(@Nullable String certificateCommonName); }
|
@Test public void asciiBytesToChars() throws Exception { String asciiCharStr = "abcdefghijklmnop\n\t\r1234567890!@#$%^&*()`\'\"<>?:{}[];,./"; byte[] asciiBytes = asciiCharStr.getBytes(StandardCharsets.US_ASCII); char[] asciiChars = JreKeystoreGenerator.asciiBytesToChars(asciiBytes); assertArrayEquals("chars -> bytes -> chars", asciiCharStr.toCharArray(), asciiChars); }
|
ResponseManufacturingFilter extends HttpsAwareFiltersAdapter { protected void captureRequest(HttpObject httpObject) { requestCaptureFilter.clientToProxyRequest(httpObject); if (httpObject instanceof HttpRequest) { HttpRequest httpRequest = (HttpRequest) httpObject; captureMethodAndUrl(httpRequest); captureRequestHeaders(httpRequest); } if (httpObject instanceof LastHttpContent) { LastHttpContent lastHttpContent = (LastHttpContent) httpObject; captureTrailingHeaders(lastHttpContent); captureRequestContent(requestCaptureFilter.getFullRequestContents()); } } <S> ResponseManufacturingFilter(HttpRequest originalRequest, ChannelHandlerContext ctx, BmpResponseManufacturer.WithState<S> responseManufacturer, BmpResponseListener responseListener); @Override HttpResponse clientToProxyRequest(HttpObject httpObject); @Override final HttpObject proxyToClientResponse(HttpObject httpObject); @Override HttpObject serverToProxyResponse(HttpObject httpObject); @Override void proxyToServerResolutionSucceeded(String serverHostAndPort, InetSocketAddress resolvedRemoteAddress); @Override void proxyToServerRequestSending(); @Override void proxyToServerResolutionFailed(String hostAndPort); @Override void proxyToServerConnectionFailed(); @Override void serverToProxyResponseTimedOut(); @Override HttpResponse proxyToServerRequest(HttpObject httpObject); @Override void proxyToServerRequestSent(); @Override void serverToProxyResponseReceiving(); @Override void serverToProxyResponseReceived(); @Override void proxyToServerConnectionQueued(); @Override InetSocketAddress proxyToServerResolutionStarted(String resolvingServerHostAndPort); @Override void proxyToServerConnectionStarted(); @Override void proxyToServerConnectionSSLHandshakeStarted(); @Override void proxyToServerConnectionSucceeded(ChannelHandlerContext serverCtx); }
|
@Test public void captureRequest() throws IOException { String bodyContent = "hello, world"; Charset bodyCharset = StandardCharsets.UTF_8; ByteBuf content = Unpooled.wrappedBuffer(bodyContent.getBytes(bodyCharset)); String url = "http: DefaultFullHttpRequest littleRequest = new DefaultFullHttpRequest(HttpVersion.HTTP_1_1, HttpMethod.POST, url, content); String contentType = MediaType.PLAIN_TEXT_UTF_8.withCharset(bodyCharset).toString(); littleRequest.headers().set(HttpHeaders.CONTENT_TYPE, contentType); BmpResponseManufacturer.WithState bmprmws = EasyMock.createMock(BmpResponseManufacturer.WithState.class); BmpResponseListener bmprl = EasyMock.createMock(BmpResponseListener.class); ResponseManufacturingFilter filter = new ResponseManufacturingFilter(littleRequest, createChannelHandlerContext(false), bmprmws, bmprl); filter.captureRequest(littleRequest); RequestCapture bmpRequest = filter.freezeRequestCapture(); ParsedRequest actual = bmpRequest.request; byte[] actualBody; try (InputStream bodyIn = actual.openBodyStream()) { actualBody = ByteStreams.toByteArray(bodyIn); } assertEquals("body", bodyContent, new String(actualBody, bodyCharset)); assertEquals("method", "POST", actual.method.name()); assertEquals("url", url, actual.url.toString()); assertEquals("content-type header", contentType, actual.getFirstHeaderValue(HttpHeaders.CONTENT_TYPE)); }
|
ResponseManufacturingFilter extends HttpsAwareFiltersAdapter { protected String reconstructUrlFromFullUrlAndHostHeader(String fullUrl, @Nullable String hostHeader) { if (isHttps()) { if (hostHeader != null) { try { URI fullUrlUri = new URI(fullUrl); URIBuilder uriBuilder = new URIBuilder(fullUrlUri); cleanHostAndPort(uriBuilder, hostHeader, fullUrlUri.getScheme()); fullUrl = uriBuilder.build().toString(); } catch (URISyntaxException e) { log.info("failed to reconstruct URL with proper host", e); } } else { log.info("no host header in request {} {}", requestAccumulator.getMethod(), fullUrl); } } return fullUrl; } <S> ResponseManufacturingFilter(HttpRequest originalRequest, ChannelHandlerContext ctx, BmpResponseManufacturer.WithState<S> responseManufacturer, BmpResponseListener responseListener); @Override HttpResponse clientToProxyRequest(HttpObject httpObject); @Override final HttpObject proxyToClientResponse(HttpObject httpObject); @Override HttpObject serverToProxyResponse(HttpObject httpObject); @Override void proxyToServerResolutionSucceeded(String serverHostAndPort, InetSocketAddress resolvedRemoteAddress); @Override void proxyToServerRequestSending(); @Override void proxyToServerResolutionFailed(String hostAndPort); @Override void proxyToServerConnectionFailed(); @Override void serverToProxyResponseTimedOut(); @Override HttpResponse proxyToServerRequest(HttpObject httpObject); @Override void proxyToServerRequestSent(); @Override void serverToProxyResponseReceiving(); @Override void serverToProxyResponseReceived(); @Override void proxyToServerConnectionQueued(); @Override InetSocketAddress proxyToServerResolutionStarted(String resolvingServerHostAndPort); @Override void proxyToServerConnectionStarted(); @Override void proxyToServerConnectionSSLHandshakeStarted(); @Override void proxyToServerConnectionSucceeded(ChannelHandlerContext serverCtx); }
|
@Test public void reconstructUrlFromFullUrlAndHostHeader() throws Exception { String[][] testCases = { new String[]{"https: new String[]{"https: new String[]{"https: new String[]{"http: new String[]{"http: new String[]{"http: new String[]{"http: }; List<String> failures = new ArrayList<>(); for (String[] testCase : testCases) { String fullUrl = testCase[0], hostHeader = testCase[1], expected = testCase[2]; boolean https = "https".equalsIgnoreCase(URI.create(fullUrl).getScheme()); HttpRequest mockRequest = new DefaultFullHttpRequest(HttpVersion.HTTP_1_1, HttpMethod.GET, ""); ResponseManufacturingFilter filter = new ResponseManufacturingFilter(mockRequest, createChannelHandlerContext(https), EasyMock.createMock(BmpResponseManufacturer.WithState.class), EasyMock.createMock(BmpResponseListener.class)); String actual = filter.reconstructUrlFromFullUrlAndHostHeader(fullUrl, hostHeader); String msg = String.format("%s reconstructed from %s and Host: %s", actual, fullUrl, hostHeader); if (!Objects.equals(expected, actual)) { failures.add(String.format("FAIL: %s (expected %s)", msg, expected)); } else { System.out.println(msg); } } failures.forEach(System.out::println); assertEquals("failures", Collections.emptyList(), failures); }
|
ResponseManufacturingFilter extends HttpsAwareFiltersAdapter { @VisibleForTesting RequestCapture freezeRequestCapture() { return requestAccumulator.freeze(); } <S> ResponseManufacturingFilter(HttpRequest originalRequest, ChannelHandlerContext ctx, BmpResponseManufacturer.WithState<S> responseManufacturer, BmpResponseListener responseListener); @Override HttpResponse clientToProxyRequest(HttpObject httpObject); @Override final HttpObject proxyToClientResponse(HttpObject httpObject); @Override HttpObject serverToProxyResponse(HttpObject httpObject); @Override void proxyToServerResolutionSucceeded(String serverHostAndPort, InetSocketAddress resolvedRemoteAddress); @Override void proxyToServerRequestSending(); @Override void proxyToServerResolutionFailed(String hostAndPort); @Override void proxyToServerConnectionFailed(); @Override void serverToProxyResponseTimedOut(); @Override HttpResponse proxyToServerRequest(HttpObject httpObject); @Override void proxyToServerRequestSent(); @Override void serverToProxyResponseReceiving(); @Override void serverToProxyResponseReceived(); @Override void proxyToServerConnectionQueued(); @Override InetSocketAddress proxyToServerResolutionStarted(String resolvingServerHostAndPort); @Override void proxyToServerConnectionStarted(); @Override void proxyToServerConnectionSSLHandshakeStarted(); @Override void proxyToServerConnectionSucceeded(ChannelHandlerContext serverCtx); }
|
@Test public void captureRequest_https() throws Exception { ImmutableHttpResponse alwaysResponse = ImmutableHttpResponse.builder(201) .content(MediaType.PLAIN_TEXT_UTF_8, CharSource.wrap("not a real server").asByteSource(StandardCharsets.UTF_8)) .build(); BmpResponseManufacturer responseManufacturer = new BmpResponseManufacturer<Object>() { @Override public ResponseCapture manufacture(Object state, RequestCapture capture) { return ResponseCapture.matched(new BmpHttpAssistant().constructResponse(capture, alwaysResponse)); } @Override public Object createFreshState() { return new Object(); } }; BrowsermobVhsConfig vhsConfig = BrowsermobVhsConfig.builder(responseManufacturer) .tlsEndpointFactory(NanohttpdTlsEndpointFactory.create(BmpTests.generateKeystoreForUnitTest("localhost"), null)) .scratchDirProvider(ScratchDirProvider.under(temporaryFolder.getRoot().toPath())) .build(); List<RequestCapture> requests = Collections.synchronizedList(new ArrayList<>()); BrowsermobVirtualHarServer server = new BrowsermobVirtualHarServer(vhsConfig) { @Override ResponseManufacturingFiltersSource createFirstFiltersSource(BmpResponseManufacturer.WithState<?> responseManufacturer, HostRewriter hostRewriter, BmpResponseListener bmpResponseListener, ResponseManufacturingFiltersSource.PassthruPredicate passthruPredicate) { return new ResponseManufacturingFiltersSource(responseManufacturer, hostRewriter, bmpResponseListener, passthruPredicate) { @Override ResponseManufacturingFilter createResponseManufacturingFilter(HttpRequest originalRequest, ChannelHandlerContext ctx, BmpResponseManufacturer.WithState<?> responseManufacturer, BmpResponseListener bmpResponseListener) { return new ResponseManufacturingFilter(originalRequest, ctx, responseManufacturer, bmpResponseListener) { @Override RequestCapture freezeRequestCapture() { RequestCapture frozen = super.freezeRequestCapture(); requests.add(frozen); return frozen; } }; } }; } }; URI requestUri = URI.create("https: StatusLine responseStatus; try (VirtualHarServerControl ctrl = server.start()) { try (CloseableHttpClient client = VhsTests.buildBlindlyTrustingHttpClient(ctrl.getSocketAddress())) { HttpGet request = new HttpGet(requestUri); try (CloseableHttpResponse response = client.execute(request)) { responseStatus = response.getStatusLine(); } } } assertEquals("response status", alwaysResponse.status, responseStatus.getStatusCode()); assertEquals("num requests parsed", 1, requests.size()); ParsedRequest parsedRequest = requests.iterator().next().request; assertEquals("parsed request uri", requestUri, parsedRequest.url); }
|
ResponseManufacturingFilter extends HttpsAwareFiltersAdapter { static boolean isDefaultPortForScheme(@Nullable String scheme, int port) { @Nullable Integer defaultPort = PortsAndSchemes.getDefaultPort(scheme); return defaultPort != null && port == defaultPort.intValue(); } <S> ResponseManufacturingFilter(HttpRequest originalRequest, ChannelHandlerContext ctx, BmpResponseManufacturer.WithState<S> responseManufacturer, BmpResponseListener responseListener); @Override HttpResponse clientToProxyRequest(HttpObject httpObject); @Override final HttpObject proxyToClientResponse(HttpObject httpObject); @Override HttpObject serverToProxyResponse(HttpObject httpObject); @Override void proxyToServerResolutionSucceeded(String serverHostAndPort, InetSocketAddress resolvedRemoteAddress); @Override void proxyToServerRequestSending(); @Override void proxyToServerResolutionFailed(String hostAndPort); @Override void proxyToServerConnectionFailed(); @Override void serverToProxyResponseTimedOut(); @Override HttpResponse proxyToServerRequest(HttpObject httpObject); @Override void proxyToServerRequestSent(); @Override void serverToProxyResponseReceiving(); @Override void serverToProxyResponseReceived(); @Override void proxyToServerConnectionQueued(); @Override InetSocketAddress proxyToServerResolutionStarted(String resolvingServerHostAndPort); @Override void proxyToServerConnectionStarted(); @Override void proxyToServerConnectionSSLHandshakeStarted(); @Override void proxyToServerConnectionSucceeded(ChannelHandlerContext serverCtx); }
|
@Test public void isDefaultPortForScheme() { assertTrue(ResponseManufacturingFilter.isDefaultPortForScheme("http", 80)); assertTrue(ResponseManufacturingFilter.isDefaultPortForScheme("https", 443)); assertFalse(ResponseManufacturingFilter.isDefaultPortForScheme("https", 8443)); assertFalse(ResponseManufacturingFilter.isDefaultPortForScheme("http", 8080)); assertFalse(ResponseManufacturingFilter.isDefaultPortForScheme("notarealscheme", 0)); assertFalse(ResponseManufacturingFilter.isDefaultPortForScheme("notarealscheme", 1003)); assertFalse(ResponseManufacturingFilter.isDefaultPortForScheme(null, 80)); }
|
HeuristicEntryMatcher implements EntryMatcher<S> { @Nullable @Override public HttpRespondable findTopEntry(S state, ParsedRequest request) { List<RatedEntry> ratedEntryList = entries.stream() .map(createEntryToRatingFunction(request, state)) .collect(Collectors.toList()); Optional<RatedEntry> topRatedEntry = ratedEntryList.stream() .filter(getRatedEntryFilter(state)) .max(getRatedEntryComparator()); if (topRatedEntry.isPresent()) { try { return topRatedEntry.get().entry.responseCreator.createRespondable(request); } catch (IOException e) { log.warn("could not create response for top-rated entry", e); } } return null; } protected HeuristicEntryMatcher(Heuristic heuristic, int thresholdExclusive, Collection<ParsedEntry> entries); static EntryMatcherFactory<T> factory(Heuristic heuristic, int thresholdExclusive); @Nullable @Override HttpRespondable findTopEntry(S state, ParsedRequest request); }
|
@Test public void findTopEntry() throws Exception { BasicHeuristic heuristic = new BasicHeuristic(); int threshold = BasicHeuristic.DEFAULT_THRESHOLD_EXCLUSIVE; String correctUrl = "http: HeuristicEntryMatcher.ParsedEntry[] entries = { createEntry("GET", "http: createEntry("GET", "http: createEntry("GET", correctUrl, 200, MediaType.PLAIN_TEXT_UTF_8, "good"), createEntry("POST", correctUrl, 200, MediaType.PLAIN_TEXT_UTF_8, "more bad"), createEntry("GET", "http: createEntry("GET", "http: }; HeuristicEntryMatcher<Object> matcher = new HeuristicEntryMatcher<>(heuristic, threshold, Arrays.asList(entries)); ParsedRequest request = Tests.createRequest("GET", correctUrl); Object state = new Object(); HttpRespondable response = matcher.findTopEntry(state, request); assertNotNull("response", response); assertEquals(200, response.getStatus()); assertEquals(1, response.streamHeaders().count()); String content = Tests.readAsString(response); assertEquals("content", "good", content); }
|
HarBridgeEntryParser implements EntryParser<E> { @Override public HttpRespondable parseResponse(ParsedRequest request, E entry) throws IOException { int status = bridge.getResponseStatus(entry); HarResponseEncoding responseEncoder = responseEncoderFactory.getEncoder(request, entry); HarResponseData responseData = bridge.getResponseData(request, entry, responseEncoder); return constructRespondable(status, responseData); } HarBridgeEntryParser(HarBridge<E> bridge, HarResponseEncoderFactory<E> responseEncoderFactory); static HarBridgeEntryParser<E> withPlainEncoder(HarBridge<E> bridge); @Override ParsedRequest parseRequest(E harEntry); @Nullable Multimap<String, Optional<String>> parseQuery(URI uri); @Override HttpRespondable parseResponse(ParsedRequest request, E entry); }
|
@Test public void parseResponse() throws Exception { Assume.assumeTrue("not yet implemented", false); }
|
HarBridgeEntryParser implements EntryParser<E> { protected static HttpRespondable constructRespondable(int status, HarResponseData responseData) throws IOException { Multimap<String, String> headers = ArrayListMultimap.create(); responseData.headers().forEach(header -> { headers.put(header.getKey(), header.getValue()); }); replaceContentLength(headers, responseData.getBody().size()); return HttpRespondable.inMemory(status, headers, responseData.getContentType(), responseData.getBody()); } HarBridgeEntryParser(HarBridge<E> bridge, HarResponseEncoderFactory<E> responseEncoderFactory); static HarBridgeEntryParser<E> withPlainEncoder(HarBridge<E> bridge); @Override ParsedRequest parseRequest(E harEntry); @Nullable Multimap<String, Optional<String>> parseQuery(URI uri); @Override HttpRespondable parseResponse(ParsedRequest request, E entry); }
|
@Test public void constructRespondable_replaceContentLengthHeaderValue() throws Exception { String data = "hello, world"; Charset charset = StandardCharsets.UTF_8; byte[] bytes = data.getBytes(charset); long originalContentLengthValue = bytes.length * 2; MediaType contentType = MediaType.PLAIN_TEXT_UTF_8.withCharset(charset); Map<String, String> originalHeaders = ImmutableMap.of(HttpHeaders.CONTENT_TYPE, contentType.toString(), HttpHeaders.CONTENT_LENGTH, String.valueOf(originalContentLengthValue)); HttpRespondable respondable = HarBridgeEntryParser.constructRespondable(200, HarResponseData.of(originalHeaders.entrySet(), contentType, ByteSource.wrap(bytes))); Multimap<String, String> headersMm = ArrayListMultimap.create(); respondable.streamHeaders().forEach(h -> { headersMm.put(h.getKey(), h.getValue()); }); Map<String, Collection<String>> headers = headersMm.asMap(); Collection<String> values = headers.get(HttpHeaders.CONTENT_LENGTH); System.out.format("%s: %s%n", HttpHeaders.CONTENT_LENGTH, values); assertEquals("num values", 1, values.size()); String finalContentLengthStr = values.iterator().next(); assertNotNull("final content length header not found", finalContentLengthStr); long finalContentLength = Long.parseLong(finalContentLengthStr); assertEquals("content length", bytes.length, finalContentLength); }
|
HarBridgeEntryParser implements EntryParser<E> { protected static void replaceContentLength(Multimap<String, String> headers, @Nullable Long value) { @Nullable String valueStr = value == null ? null : value.toString(); replaceHeaders(headers, HttpHeaders.CONTENT_LENGTH, valueStr); } HarBridgeEntryParser(HarBridge<E> bridge, HarResponseEncoderFactory<E> responseEncoderFactory); static HarBridgeEntryParser<E> withPlainEncoder(HarBridge<E> bridge); @Override ParsedRequest parseRequest(E harEntry); @Nullable Multimap<String, Optional<String>> parseQuery(URI uri); @Override HttpRespondable parseResponse(ParsedRequest request, E entry); }
|
@Test public void replaceContentLengthHeaderValue_removeMultiple() throws Exception { checkState("content-length".equalsIgnoreCase(HttpHeaders.CONTENT_LENGTH)); Multimap<String, String> headers = ArrayListMultimap.create(); headers.put("content-length", "100"); headers.put("Content-Length", "150"); headers.put("Content-Type", "application/octet-stream"); HarBridgeEntryParser.replaceContentLength(headers, null); assertEquals("headers remaining", ImmutableMultimap.of("Content-Type", "application/octet-stream"), headers); }
|
HarBridgeEntryParser implements EntryParser<E> { protected static <V> void replaceHeaders(Multimap<String, V> headers, String headerName, @Nullable V value) { Set<String> caseSensitiveKeys = headers.keySet().stream() .filter(headerName::equalsIgnoreCase) .collect(Collectors.toSet()); if (value != null && caseSensitiveKeys.size() == 1) { Collection<V> vals = headers.get(caseSensitiveKeys.iterator().next()); if (vals.size() == 1) { if (value.equals(vals.iterator().next())) { return; } } } caseSensitiveKeys.forEach(headers::removeAll); if (value != null) { headers.put(headerName, value); } } HarBridgeEntryParser(HarBridge<E> bridge, HarResponseEncoderFactory<E> responseEncoderFactory); static HarBridgeEntryParser<E> withPlainEncoder(HarBridge<E> bridge); @Override ParsedRequest parseRequest(E harEntry); @Nullable Multimap<String, Optional<String>> parseQuery(URI uri); @Override HttpRespondable parseResponse(ParsedRequest request, E entry); }
|
@SuppressWarnings("UnnecessaryBoxing") @Test public void replaceHeaderValue_noReplacementIfSameValue() throws Exception { Multimap<String, Long> headers = ArrayListMultimap.create(); long stamp = System.currentTimeMillis(); Long val1 = new Long(stamp); Long val2 = new Long(stamp); headers.put("a", val1); headers.put("b", 0L); HarBridgeEntryParser.replaceHeaders(headers, "a", val2); assertSame(val1, headers.get("a").iterator().next()); assertFalse(headers.get("b").isEmpty()); }
|
HarReplayMain { @SuppressWarnings("SameParameterValue") protected void printVersion(PrintStream out) { Properties p = loadMavenProperties(); String name = p.getProperty("project.parent.name", "har-replay"); String version = p.getProperty("project.version", DEFAULT_VERSION); URL location = getClass().getProtectionDomain().getCodeSource().getLocation(); out.format("%s %s (in %s)%n", name, version, location); } HarReplayMain(); @VisibleForTesting HarReplayMain(OptionParser parser); static void main(String[] args); }
|
@Test public void printVersion() throws UnsupportedEncodingException { ByteArrayOutputStream baos = new ByteArrayOutputStream(64); PrintStream ps = new PrintStream(baos, true); new HarReplayMain().printVersion(ps); ps.flush(); String actual = baos.toString(UTF_8.name()); System.out.print(actual); assertFalse("actual version string", actual.contains(HarReplayMain.DEFAULT_VERSION)); }
|
ImmutableListTypeAdapterFactory implements TypeAdapterFactory { @Override public <T> TypeAdapter<T> create(Gson gson, TypeToken<T> type) { if (!ImmutableList.class.equals(type.getRawType())) { return null; } return (TypeAdapter<T>) createImmutableListTypeAdapter(gson, type); } @Override TypeAdapter<T> create(Gson gson, TypeToken<T> type); }
|
@Test public void create() { ListHolder original = new ListHolder(); original.items = ImmutableList.of(new ListItem("beatrice", 3), new ListItem("henry", 5)); String json = gson().toJson(original); System.out.format("json:%n%s%n", json); ListHolder deserialized = gson().fromJson(json, ListHolder.class); System.out.format("deserialized:%n%s%n", deserialized); assertEquals("deserialized", original, deserialized); }
@Test public void deserializeImmutableList() throws Exception { Type type = new TypeToken<ImmutableList<String>>(){}.getType(); ImmutableList<String> list = new GsonBuilder() .registerTypeAdapterFactory(new ImmutableListTypeAdapterFactory()) .create() .fromJson("[\"a\", \"b\", \"c\"]", type); assertEquals(ImmutableList.of("a", "b", "c"), list); }
@Test public void deserializeEmptyList() throws Exception { Type type = new TypeToken<ImmutableList<String>>(){}.getType(); ImmutableList<String> list = new GsonBuilder() .registerTypeAdapterFactory(new ImmutableListTypeAdapterFactory()) .create() .fromJson("[]", type); assertEquals(ImmutableList.of(), list); }
@Test public void writeList() throws Exception { Gson gson = new GsonBuilder() .registerTypeAdapterFactory(new ImmutableListTypeAdapterFactory()) .create(); ImmutableList<Integer> list = ImmutableList.of(1, 2, 3); String json = gson.toJson(list); assertEquals(new Gson().toJson(list), json); }
@Test public void nestedList_serialize() throws Exception { ImmutableList<ImmutableList<Integer>> listOfLists = ImmutableList.of(ImmutableList.of(1, 2, 3), ImmutableList.of(4, 5, 6)); TypeAdapterFactory adapterFactory = new ImmutableListTypeAdapterFactory(); String json = new GsonBuilder().registerTypeAdapterFactory(adapterFactory).create().toJson(listOfLists); String expected = "[[1,2,3],[4,5,6]]"; assertEquals("json", expected, json); }
|
ReplacingInterceptorVariableDictionary implements VariableDictionary { @Nullable @Override public Optional<String> substitute(String variableName) { try { @Nullable String substitution = substituteOrThrow(variableName); return Optional.ofNullable(substitution); } catch (UnknownVariableNameException e) { return null; } } ReplacingInterceptorVariableDictionary(ParsedRequest request); @Nullable @Override Optional<String> substitute(String variableName); static final String KEY_REQUEST_URL; static final String KEY_REQUEST_METHOD; static final String PREFIX_KEY_REQUEST_HEADER; static final String PREFIX_KEY_REQUEST_QUERY; }
|
@Test public void substitute() { @Nullable Optional<String> result = new ReplacingInterceptorVariableDictionary(testCase.request) .substitute(testCase.variableName); assertEquals("variable name found", testCase.expectNameValid, result != null); if (result != null) { String value = result.orElse(null); assertEquals("substituted value", testCase.expectedValueIfValid, value); } }
|
EasierHarReaderFactory implements HarReaderFactory { @Override public HarReader createReader() { return new HarReader(createMapperFactory()); } @Override HarReader createReader(); }
|
@Test public void readHarGeneratedByBrowsermob() throws Exception { File harFile = Fixtures.copyBrowsermobGeneratedHarFile(temporaryFolder.getRoot().toPath()); Har har = new EasierHarReaderFactory().createReader().readFromFile(harFile, HarReaderMode.STRICT); HarEntry entryWithBadDate = har.getLog().getEntries().iterator().next(); assertNotNull("date with bad format", entryWithBadDate.getStartedDateTime()); assertNotEquals("date to epoch millis", 0L, entryWithBadDate.getStartedDateTime().getTime()); }
|
MappingEntryMatcher implements EntryMatcher<S> { protected Multimap<String, String> constructHeaders(File file, MediaType contentType) { Multimap<String, String> headers = ArrayListMultimap.create(); headers.put(HttpHeaders.CONTENT_TYPE, contentType.toString()); readFileAttributes(file).forEach(headers::put); return headers; } MappingEntryMatcher(Iterable<Mapping> mappings, Path fileResolutionRoot); @Nullable @Override HttpRespondable findTopEntry(S state, ParsedRequest request); }
|
@Test public void constructHeaders() throws Exception { MappingEntryMatcher m = new MappingEntryMatcher(ImmutableList.of(), temporaryFolder.getRoot().toPath()); Random random = new Random(MappingEntryMatcherTest.class.getName().hashCode()); int length = 1024; byte[] bytes = new byte[length]; random.nextBytes(bytes); File file = temporaryFolder.newFile(); Multimap<String, String> rawHeaders = m.constructHeaders(file, MediaType.OCTET_STREAM); NameValuePairList.StringMapEntryList headers = NameValuePairList.StringMapEntryList.caseInsensitive(rawHeaders.entries()); assertEquals("num content-length headers", 1, headers.streamValues(HttpHeaders.CONTENT_LENGTH).count()); assertEquals("num content-type headers", 1, headers.streamValues(HttpHeaders.CONTENT_TYPE).count()); }
|
VhsReplayManager implements ReplayManager { @Override public ReplaySessionControl start(ReplaySessionConfig sessionConfig) throws IOException { EntryMatcher harEntryMatcher = buildHarEntryMatcher(sessionConfig); EntryMatcher compositeEntryMatcher = enhanceEntryMatcherFromConfig(harEntryMatcher, sessionConfig.replayServerConfig); List<ResponseInterceptor> interceptors = new ArrayList<>(); interceptors.addAll(buildInterceptorsForReplacements(sessionConfig.replayServerConfig.replacements)); interceptors.addAll(buildInterceptorsForTransforms(sessionConfig.replayServerConfig.responseHeaderTransforms)); int port = sessionConfig.port; VirtualHarServer vhs = createVirtualHarServer(port, sessionConfig.scratchDir, compositeEntryMatcher, interceptors, config.bmpResponseListener); VirtualHarServerControl ctrl = vhs.start(); Runnable stopListener = () -> { sessionConfig.serverTerminationCallbacks.forEach(c -> { c.terminated(null); }); }; return new VhsReplaySessionControl(ctrl, true, stopListener); } VhsReplayManager(); VhsReplayManager(VhsReplayManagerConfig config); protected VhsReplayManager(VhsReplayManagerConfig config, EntryMatcherFactory entryMatcherFactory); @Override ReplaySessionControl start(ReplaySessionConfig sessionConfig); }
|
@Test public void unmatchedDoesNotHang() throws Exception { ReplayManager replayManager = new VhsReplayManager(); File harFile = temporaryFolder.newFile(); Resources.asByteSource(getClass().getResource("/empty.har")).copyTo(Files.asByteSink(harFile)); ReplaySessionConfig config = ReplaySessionConfig.builder(temporaryFolder.getRoot().toPath()) .build(harFile); int numTrials = 12; URI url = URI.create("http: try (ReplaySessionControl ctrl = replayManager.start(config)) { HostAndPort proxyAddress = ctrl.getSocketAddress(); for (int i = 0; i < numTrials; i++) { System.out.format("[%2d] fetching %s%n", i + 1, url); ImmutableHttpResponse rsp = Tests.fetch(proxyAddress, url); String actual = rsp.data.asCharSource(StandardCharsets.UTF_8).read(); assertEquals("repsonse content", "404 Not Found", actual); } } }
@Test public void acceptEncodingIsObeyed() throws Exception { io.github.mike10004.vhs.harbridge.Hars.class.getName(); ReplayManager replayManager = new VhsReplayManager(); Fixture fixture = fixturesRule.getFixtures().http(); File harFile = fixture.harFile(); ReplaySessionConfig config = ReplaySessionConfig.builder(temporaryFolder.getRoot().toPath()) .build(harFile); URI url = fixture.startUrl(); try (ReplaySessionControl ctrl = replayManager.start(config)) { HostAndPort proxyAddress = ctrl.getSocketAddress(); System.out.format("fetching %s%n", url); ImmutableHttpResponse rsp = Tests.fetchWithNoAcceptEncodingRequestHeader(proxyAddress, url); String actual = rsp.data.asCharSource(StandardCharsets.UTF_8).read(); boolean allAscii = ASCII.matchesAllOf(actual); if (!allAscii) { System.out.format("text \"%s\" has first non-ascii character at index %d%n", StringEscapeUtils.escapeJava(StringUtils.abbreviateMiddle(actual, "[...]", 64)), ASCII.negate().indexIn(actual)); } assertTrue("response content all ascii", allAscii); } }
|
HarReplayMain { static Properties loadMavenProperties() { Properties p = new Properties(); URL resource = HarReplayMain.class.getResource("/har-replay-exec/maven.properties"); if (resource == null) { log.info("maven.properties is not present on classpath"); return p; } try (InputStream in = resource.openStream()) { p.load(in); } catch (IOException e) { log.warn("failed to read from " + resource, e); } return p; } HarReplayMain(); @VisibleForTesting HarReplayMain(OptionParser parser); static void main(String[] args); }
|
@Test public void loadMavenProperties() { Properties p = HarReplayMain.loadMavenProperties(); p.stringPropertyNames().forEach(key -> { String value = p.getProperty(key); System.out.format("%s = %s%n", key, value); assertFalse("expect filtered: " + value, value.startsWith("${")); }); }
|
CompositeEntryMatcher implements EntryMatcher<S> { @Nullable @Override public HttpRespondable findTopEntry(S state, ParsedRequest request) { for (EntryMatcher<? super S> component : components) { HttpRespondable respondable = component.findTopEntry(state, request); if (respondable != null) { return respondable; } } return null; } CompositeEntryMatcher(Iterable<EntryMatcher<? super S>> components); @Nullable @Override HttpRespondable findTopEntry(S state, ParsedRequest request); }
|
@Test public <S> void findTopEntry() { CompositeEntryMatcher<T> matcher = new CompositeEntryMatcher<>(testCase.components); HttpRespondable response = matcher.findTopEntry(testCase.state, testCase.request); assertEquals(testCase.describe(), testCase.expectedResponse, response); }
|
ReplacingInterceptor implements ResponseInterceptor { protected static String collectText(HttpRespondable respondable) throws IOException { FlushedContent content = toByteArray(respondable); Charset charset = content.contentType.charset().or(DEFAULT_INTERNET_TEXT_CHARSET); return charset.newDecoder().decode(ByteBuffer.wrap(content.data)).toString(); } ReplacingInterceptor(VhsReplayManagerConfig config, Replacement replacement); @Override HttpRespondable intercept(ParsedRequest parsedRequest, HttpRespondable httpRespondable); }
|
@Test public void collectText() throws IOException { String text = "\"<!doctype html>\\n<html>\\n<head>\\n <title>ABCDEFG Domain</title>\\n\\n <meta charset=\\\"utf-8\\\" />\\n <meta http-equiv=\\\"Content-type\\\" content=\\\"text/html; charset=utf-8\\\" />\\n <meta name=\\\"viewport\\\" content=\\\"width=device-width, initial-scale=1\\\" />\\n <style type=\\\"text/css\\\">\\n body {\\n background-color: #f0f0f2;\\n margin: 0;\\n padding: 0;\\n font-family: \\\"Open Sans\\\", \\\"Helvetica Neue\\\", Helvetica, Arial, sans-serif;\\n \\n }\\n div {\\n width: 600px;\\n margin: 5em auto;\\n padding: 50px;\\n background-color: #fff;\\n border-radius: 1em;\\n }\\n a:link, a:visited {\\n color: #38488f;\\n text-decoration: none;\\n }\\n @media (max-width: 700px) {\\n body {\\n background-color: #fff;\\n }\\n div {\\n width: auto;\\n margin: 0 auto;\\n border-radius: 0;\\n padding: 1em;\\n }\\n }\\n </style> \\n</head>\\n\\n<body>\\n<div>\\n <h1>Example Domain</h1>\\n <p>This domain is established to be used for illustrative examples in documents. You may use this\\n domain in examples without prior coordination or asking for permission.</p>\\n <p><a href=\\\"http: MediaType contentType = MediaType.HTML_UTF_8; checkState(contentType.charset().isPresent()); byte[] gzipped = gzip(text.getBytes(contentType.charset().get())); String contentEncoding = "gzip"; HttpRespondable r = ImmutableHttpRespondable.builder(200) .bodySource(ByteSource.wrap(gzipped)) .contentType(contentType) .header(HttpHeaders.CONTENT_ENCODING, contentEncoding) .build(); String actual = ReplacingInterceptor.collectText(r); assertEquals("text", text, actual); }
|
ReplacingInterceptor implements ResponseInterceptor { protected static <T> WritingActionResult<T> writeByteArray(WritingAction<T> action, int expectedOutputLength) throws IOException { ByteArrayOutputStream baos = new ByteArrayOutputStream(expectedOutputLength); T returnValue = action.write(baos); baos.flush(); byte[] data = baos.toByteArray(); return new WritingActionResult<>(returnValue, data); } ReplacingInterceptor(VhsReplayManagerConfig config, Replacement replacement); @Override HttpRespondable intercept(ParsedRequest parsedRequest, HttpRespondable httpRespondable); }
|
@Test public void intercept_performed() throws Exception { Replacement replacement = new Replacement(StringLiteral.of("foo"), StringLiteral.of("bar")); MediaType contentType = MediaType.PLAIN_TEXT_UTF_8; Charset charset = contentType.charset().get(); byte[] body = "This is a foo document".getBytes(charset); byte[] expected = "This is a bar document".getBytes(charset); HttpRespondable actual = doIntercept(replacement, body, contentType); WritingActionResult<MediaType> writeResult = ReplacingInterceptor.writeByteArray(actual::writeBody, expected.length); assertArrayEquals("actual bytes", expected, writeResult.byteArray); assertEquals("content type", contentType, writeResult.actionReturnValue); }
@Test public void intercept_performed_regex() throws Exception { Replacement replacement = new Replacement(RegexHolder.of(" h(\\S+)"), StringLiteral.of(" x$1")); MediaType contentType = MediaType.PLAIN_TEXT_UTF_8; Charset charset = contentType.charset().get(); byte[] body = "We said hello to horticulturalists with handkerchiefs".getBytes(charset); String expected = "We said xello to xorticulturalists with xandkerchiefs"; HttpRespondable actual = doIntercept(replacement, body, contentType); WritingActionResult<MediaType> writeResult = ReplacingInterceptor.writeByteArray(actual::writeBody, expected.length()); String actualText = new String(writeResult.byteArray, writeResult.actionReturnValue.charset().get()); assertEquals("actual bytes", expected, actualText); assertEquals("content type", contentType, writeResult.actionReturnValue); }
@Test public void intercept_notPerformed() throws Exception { Replacement replacement = new Replacement(StringLiteral.of("foo"), StringLiteral.of("bar")); MediaType contentType = MediaType.PNG; Charset charset = StandardCharsets.UTF_8; byte[] body = "This is a foo document".getBytes(charset); byte[] expected = "This is a bar document".getBytes(charset); HttpRespondable actual = doIntercept(replacement, body, contentType); WritingActionResult<MediaType> writeResult = ReplacingInterceptor.writeByteArray(actual::writeBody, expected.length); assertArrayEquals("actual bytes", body, writeResult.byteArray); assertEquals("content type", contentType, writeResult.actionReturnValue); }
|
ReplacingInterceptor implements ResponseInterceptor { protected static boolean isTextType(@Nullable MediaType contentType) { if (contentType == null) { return false; } if (contentType.is(MediaType.ANY_TEXT_TYPE)) { return true; } MediaType noCharsetType = contentType.withoutParameters(); for (MediaType textLike : parameterlessTextLikeTypes) { if (textLike.equals(noCharsetType)) { return true; } } return false; } ReplacingInterceptor(VhsReplayManagerConfig config, Replacement replacement); @Override HttpRespondable intercept(ParsedRequest parsedRequest, HttpRespondable httpRespondable); }
|
@Test public void isTextType() { MediaType[] expectTrue = { MediaType.PLAIN_TEXT_UTF_8, MediaType.JAVASCRIPT_UTF_8, MediaType.TEXT_JAVASCRIPT_UTF_8, MediaType.APPLICATION_XML_UTF_8, MediaType.HTML_UTF_8, MediaType.XHTML_UTF_8, MediaType.CSV_UTF_8, MediaType.CSS_UTF_8, MediaType.XML_UTF_8, MediaType.JSON_UTF_8, }; Stream.of(expectTrue).forEach(ct -> confirmIsTextType(ct, true)); MediaType[] expectFalse = { null, MediaType.PNG, MediaType.JPEG, MediaType.OCTET_STREAM, MediaType.FLV_VIDEO, MediaType.BZIP2, MediaType.MICROSOFT_WORD, MediaType.OPENDOCUMENT_TEXT, }; Stream.of(expectFalse).forEach(ct -> confirmIsTextType(ct, false)); }
|
VhsReplayManagerConfig { public static VhsReplayManagerConfig getDefault() { return DEFAULT; } private VhsReplayManagerConfig(Builder builder); static VhsReplayManagerConfig getDefault(); static Builder builder(); final Path mappedFileResolutionRoot; final KeystoreGenerator keystoreGenerator; final BmpResponseListener bmpResponseListener; final HarReaderFactory harReaderFactory; final HarReaderMode harReaderMode; }
|
@Test public void getDefault() { assertTrue(VhsReplayManagerConfig.getDefault().harReaderFactory instanceof EasierHarReaderFactory); }
|
HeaderTransformInterceptor implements ResponseInterceptor { @Override public HttpRespondable intercept(ParsedRequest parsedRequest, HttpRespondable httpRespondable) { if (isAnyTransformRequired(httpRespondable)) { return new HeaderTransformRespondableWrapper(httpRespondable); } return httpRespondable; } HeaderTransformInterceptor(VhsReplayManagerConfig config, ResponseHeaderTransform headerTransform); @Override HttpRespondable intercept(ParsedRequest parsedRequest, HttpRespondable httpRespondable); }
|
@Test public void intercept() { String expectedValueAfterReplacement = "https: ResponseHeaderTransform headerTransform = ResponseHeaderTransform.valueByName(StringLiteral.of(HttpHeaders.LOCATION), StringLiteral.of(expectedValueAfterReplacement)); Multimap<String, String> headers = ImmutableMultimap.of(HttpHeaders.LOCATION, "https: String actualValueAfterReplacement = testIntercept(headers, headerTransform, HttpHeaders.LOCATION); assertEquals("location header value", expectedValueAfterReplacement, actualValueAfterReplacement); }
|
HeaderTransformInterceptor implements ResponseInterceptor { protected boolean isAnyTransformRequired(Map.Entry<String, String> header) { return headerTransform.getNameMatch().isMatchingHeaderName(header.getKey()) && headerTransform.getValueMatch().isMatchingHeaderValue(header.getKey(), header.getValue()); } HeaderTransformInterceptor(VhsReplayManagerConfig config, ResponseHeaderTransform headerTransform); @Override HttpRespondable intercept(ParsedRequest parsedRequest, HttpRespondable httpRespondable); }
|
@Test public void isAnyTransformRequired() { testIsAnyTransformRequired(ResponseHeaderTransform.name(StringLiteral.of("X"), StringLiteral.of("Y")), true, "W", "www", "X", "xxx", "Z", "zzz"); testIsAnyTransformRequired(ResponseHeaderTransform.name(StringLiteral.of("X"), StringLiteral.of("Y")), false, "W", "www", "Y", "yyy", "Z", "zzz"); ResponseHeaderTransform locationHeaderDropHttps = ReplayManagerTestBase.createLocationHttpsToHttpTransform(); testIsAnyTransformRequired(locationHeaderDropHttps, true, HttpHeaders.LOCATION, "https: }
@Test public void isAnyTransformRequired_header() { Map.Entry<String, String> header = new SimpleImmutableEntry<>(HttpHeaders.LOCATION, "https: ResponseHeaderTransform locationHeaderDropHttps = ReplayManagerTestBase.createLocationHttpsToHttpTransform(); assertTrue("name match", locationHeaderDropHttps.getNameMatch().isMatchingHeaderName(header.getKey())); assertTrue("value match", locationHeaderDropHttps.getValueMatch().isMatchingHeaderValue(header.getKey(), header.getValue())); HeaderTransformInterceptor interceptor = newInterceptor(locationHeaderDropHttps); boolean anyRequired = interceptor.isAnyTransformRequired(header); assertTrue("transform required on " + header, anyRequired); }
|
WrappingResponseEncoding implements HarResponseEncoding { @VisibleForTesting static boolean canServeOriginalResponseContentEncoding(List<String> parsedResponseContentEncodings, @Nullable String acceptEncodingHeaderValue) { List<WeightedEncoding> acceptsWeighted = parseAcceptedEncodings(acceptEncodingHeaderValue); return canServeOriginalResponseContentEncoding(parsedResponseContentEncodings, acceptsWeighted); } WrappingResponseEncoding(Iterable<Map.Entry<String, HttpContentCodec>> codecs); @Override HarResponseData transformUnencoded(HarResponseData unencoded); static HarResponseEncoding fromHeaderValues(@Nullable String contentEncoding, @Nullable String acceptEncoding); }
|
@Test public void canServeOriginalResponseContentEncoding() { test_canServeOriginalResponseContentEncoding(true, "gzip", "gzip"); test_canServeOriginalResponseContentEncoding(true, "gzip", "deflate, gzip;q=1.0, *;q=0.5"); test_canServeOriginalResponseContentEncoding(true, "gzip", "gzip, deflate, br"); test_canServeOriginalResponseContentEncoding(true, "gzip, br", "gzip, deflate, br"); test_canServeOriginalResponseContentEncoding(false, "gzip", null); test_canServeOriginalResponseContentEncoding(false, "gzip", ""); test_canServeOriginalResponseContentEncoding(false, "gzip", "deflate;q=1.0, gzip;q=0.0, *;q=0.5"); test_canServeOriginalResponseContentEncoding(true, null, null); test_canServeOriginalResponseContentEncoding(true, null, ""); test_canServeOriginalResponseContentEncoding(true, "", null); test_canServeOriginalResponseContentEncoding(true, "", ""); test_canServeOriginalResponseContentEncoding(true, "identity", null); test_canServeOriginalResponseContentEncoding(true, null, "gzip, deflate, br"); test_canServeOriginalResponseContentEncoding(true, "", "gzip, deflate, br"); test_canServeOriginalResponseContentEncoding(true, "identity", "gzip, deflate, br"); }
|
HeaderTransformInterceptor implements ResponseInterceptor { protected Map.Entry<String, String> transform(Map.Entry<String, String> header) { String name = header.getKey(), value = header.getValue(); String toName = headerTransform.getNameImage().transformHeaderName(name, nameMatchRegex); String toValue = headerTransform.getValueImage().transformHeaderValue(name, valueMatchRegex, value); if (!Objects.equals(name, toName) || !Objects.equals(value, toValue)) { return new SimpleImmutableEntry<>(toName, toValue); } else { return header; } } HeaderTransformInterceptor(VhsReplayManagerConfig config, ResponseHeaderTransform headerTransform); @Override HttpRespondable intercept(ParsedRequest parsedRequest, HttpRespondable httpRespondable); }
|
@Test public void applyRegexTransform() { ResponseHeaderTransform locationHeaderDropHttps = ReplayManagerTestBase.createLocationHttpsToHttpTransform(); HeaderTransformInterceptor interceptor = newInterceptor(locationHeaderDropHttps); Map.Entry<String, String> locationHeaderBefore = new SimpleImmutableEntry<>(HttpHeaders.LOCATION, "https: Map.Entry<String, String> expectedAfter = new SimpleImmutableEntry<>(HttpHeaders.LOCATION, "http: Map.Entry<String, String> actualAfter = interceptor.transform(locationHeaderBefore); assertEquals("transformed location header", expectedAfter, actualAfter); }
|
NameValuePairList { public static <T> NameValuePairList<T> empty() { return (NameValuePairList<T>) StringMapEntryList.empty(); } NameValuePairList(Iterable<? extends T> pairs, Function<? super T, String> nameGetter, Function<? super T, String> valueGetter, BiPredicate<? super String, ? super String> nameMatcher); static NameValuePairList<T> empty(); @Nullable String getFirstValue(String name); Stream<String> streamValues(String name); ImmutableList<String> listValues(String name); static NameValuePairList<T> caseSensitive(Iterable<T> pairs, Function<? super T, String> nameGetter, Function<? super T, String> valueGetter); static NameValuePairList<T> caseInsensitive(Iterable<T> pairs, Function<? super T, String> nameGetter, Function<? super T, String> valueGetter); }
|
@Test public void empty() { NameValuePairList<org.apache.http.NameValuePair> list = NameValuePairList.empty(); testEmpty(list); }
@Test public void StringMapEntryList_empty() { testEmpty(StringMapEntryList.empty()); }
|
NameValuePairList { public static <T> NameValuePairList<T> caseInsensitive(Iterable<T> pairs, Function<? super T, String> nameGetter, Function<? super T, String> valueGetter) { return new NameValuePairList<>(pairs, nameGetter, valueGetter, CASE_INSENSITIVE_MATCHER); } NameValuePairList(Iterable<? extends T> pairs, Function<? super T, String> nameGetter, Function<? super T, String> valueGetter, BiPredicate<? super String, ? super String> nameMatcher); static NameValuePairList<T> empty(); @Nullable String getFirstValue(String name); Stream<String> streamValues(String name); ImmutableList<String> listValues(String name); static NameValuePairList<T> caseSensitive(Iterable<T> pairs, Function<? super T, String> nameGetter, Function<? super T, String> valueGetter); static NameValuePairList<T> caseInsensitive(Iterable<T> pairs, Function<? super T, String> nameGetter, Function<? super T, String> valueGetter); }
|
@Test public void caseInsensitive() { ArrayPairList list = new ArrayPairList(ArrayPairList.caseInsensitiveMatcher(), "Foo", "bar", "baz", "gaw"); assertEquals("case-insensitive retrieval", "bar", list.getFirstValue("foo")); }
|
NameValuePairList { public static <T> NameValuePairList<T> caseSensitive(Iterable<T> pairs, Function<? super T, String> nameGetter, Function<? super T, String> valueGetter) { return new NameValuePairList<>(pairs, nameGetter, valueGetter, CASE_SENSITIVE_MATCHER); } NameValuePairList(Iterable<? extends T> pairs, Function<? super T, String> nameGetter, Function<? super T, String> valueGetter, BiPredicate<? super String, ? super String> nameMatcher); static NameValuePairList<T> empty(); @Nullable String getFirstValue(String name); Stream<String> streamValues(String name); ImmutableList<String> listValues(String name); static NameValuePairList<T> caseSensitive(Iterable<T> pairs, Function<? super T, String> nameGetter, Function<? super T, String> valueGetter); static NameValuePairList<T> caseInsensitive(Iterable<T> pairs, Function<? super T, String> nameGetter, Function<? super T, String> valueGetter); }
|
@Test public void caseSensitive() { ArrayPairList list = new ArrayPairList(ArrayPairList.caseSensitiveMatcher(), "Foo", "Bar", "foo", "bar"); assertEquals("case-insensitive retrieval", "bar", list.getFirstValue("foo")); assertNull("not present", list.getFirstValue("fOO")); }
|
Hars { static TypedContent getUncompressedContent(@Nullable String contentType, @Nullable String text, @Nullable Long bodySize, @Nullable Long contentSize, @Nullable String contentEncodingHeaderValue, @Nullable String harContentEncoding, @SuppressWarnings("unused") @Nullable String comment, Charset defaultCharset) { contentType = Strings.nullToEmpty(contentType).trim(); if (contentType.isEmpty()) { contentType = MediaType.OCTET_STREAM.toString(); } MediaType mediaType; try { mediaType = MediaType.parse(contentType); } catch (RuntimeException e) { log.info("failed to parse content-type \"{}\"", StringEscapeUtils.escapeJava(contentType)); mediaType = MediaType.OCTET_STREAM; } if (text == null) { return TypedContent.identity(ByteSource.empty(), mediaType); } boolean base64 = isBase64Encoded(contentType, text, harContentEncoding, bodySize); if (base64) { ByteSource decodedDataSource = decodingSource(text, contentEncodingHeaderValue, harContentEncoding, bodySize, contentSize); return TypedContent.identity(decodedDataSource, mediaType); } else { @Nullable Charset charset_ = null; try { charset_ = MediaType.parse(contentType).charset().orNull(); } catch (RuntimeException ignore) { } Charset adjustedCharset = adjustCharset(text, charset_, defaultCharset); ByteSource data = CharSource.wrap(text).asByteSource(adjustedCharset); MediaType adjustedContentType = mediaType.withCharset(adjustedCharset); return TypedContent.identity(data, adjustedContentType); } } static boolean isBase64Encoded(String contentType, String text, @Nullable String harContentEncoding, @Nullable Long bodySize); @Nullable static ByteSource getRequestPostData(@Nullable List<NameValuePair> params, String contentType, String postDataText, @Nullable Long requestBodySize, @Nullable String postDataComment, Charset defaultCharset); static TypedContent translateResponseContent( String contentType,
@Nullable String text,
@Nullable Long bodySize,
@Nullable Long contentSize,
@Nullable String contentEncodingHeaderValue,
@Nullable String harContentEncoding,
@SuppressWarnings("unused") @Nullable String comment,
Charset defaultCharset); static HarHeader newHarHeader(String name, String value); }
|
@Test public void getUncompressedContent() throws Exception { String HEX_BYTES = "E29C93"; byte[] bytes = BaseEncoding.base16().decode(HEX_BYTES); String text = new String(bytes, UTF_8); System.out.format("text: %s%n", text); MediaType contentType = MediaType.PLAIN_TEXT_UTF_8.withoutParameters(); TypedContent translation = Hars.getUncompressedContent(contentType.toString(), text, null, null, null, null, null, StandardCharsets.UTF_8); ByteSource data = translation.asByteSource(); String hexActual = BaseEncoding.base16().encode(data.read()); assertEquals("result", HEX_BYTES, hexActual); }
|
Hars { static Charset adjustCharset(String text, @Nullable Charset charset, Charset defaultCharset) { requireNonNull(defaultCharset, "default charset"); text = Strings.nullToEmpty(text); if (charset == null) { return defaultCharset; } CharsetEncoder encoder = charset.newEncoder(); if (encoder.canEncode(text)) { return charset; } return StandardCharsets.UTF_8; } static boolean isBase64Encoded(String contentType, String text, @Nullable String harContentEncoding, @Nullable Long bodySize); @Nullable static ByteSource getRequestPostData(@Nullable List<NameValuePair> params, String contentType, String postDataText, @Nullable Long requestBodySize, @Nullable String postDataComment, Charset defaultCharset); static TypedContent translateResponseContent( String contentType,
@Nullable String text,
@Nullable Long bodySize,
@Nullable Long contentSize,
@Nullable String contentEncodingHeaderValue,
@Nullable String harContentEncoding,
@SuppressWarnings("unused") @Nullable String comment,
Charset defaultCharset); static HarHeader newHarHeader(String name, String value); }
|
@Test public void adjustCharset() throws Exception { Table<String, Optional<Charset>, Charset> testCases = ImmutableTable.<String, Optional<Charset>, Charset>builder() .put("", Optional.of(US_ASCII), US_ASCII) .put("abcdef", Optional.of(US_ASCII), US_ASCII) .put("Fractions: " + decodeFromHex("BCBDBE", ISO_8859_1), Optional.of(US_ASCII), UTF_8) .put("abcdef", Optional.of(ISO_8859_1), ISO_8859_1) .put("abcdef", Optional.of(UTF_8), UTF_8) .put("abc \uD83C\uDCA1\uD83C\uDCA8\ud83c\udcd1\ud83c\udcd8\ud83c\udcd3", Optional.of(ISO_8859_1), UTF_8) .build(); testCases.cellSet().forEach(cell -> { String text = cell.getRowKey(); @Nullable Charset charset = cell.getColumnKey().orElse(null); Charset expected = cell.getValue(); Charset actual = Hars.adjustCharset(text, charset, UTF_8); String description = String.format("\"%s\" with suggestion %s", StringEscapeUtils.escapeJava(text), charset); System.out.format("%s -> %s (expecting %s)%n", description, actual, expected); assertEquals(description, expected, actual); }); }
|
NorootedAndroidCollectorImpl implements IDataCollector, IVideoImageSubscriber { @Override public StatusResult startCollector(boolean isCommandLine, String tracepath, VideoOption videoOption_deprecated, String password) { return this.startCollector(isCommandLine, tracepath, videoOption_deprecated, false, null, null, password); } @Autowired void setMetaDataHelper(IMetaDataHelper metaDataHelper); @Autowired void setAndroid(IAndroid android); @Autowired void setExternalProcessRunner(IExternalProcessRunner runner); @Autowired void setFileManager(IFileManager filemanager); void setDevice(IDevice aDevice); @Autowired void setAdbService(IAdbService adbservice); @Autowired void setVideoCapture(IVideoCapture videocapture); @Autowired void setThreadExecutor(IThreadExecutor thread); @Autowired void setFileExtactor(IReadWriteFileExtractor extractor); @Override String getName(); @Override void addDeviceStatusSubscriber(IDeviceStatus subscriber); @Override void addVideoImageSubscriber(IVideoImageSubscriber subscriber); @Override void receiveImage(BufferedImage videoimage); @Override int getMajorVersion(); @Override String getMinorVersion(); @Override DataCollectorType getType(); @Override boolean isRunning(); void stopRunning(); @Override String[] getLog(); @Override StatusResult startCollector(boolean isCommandLine, String tracepath, VideoOption videoOption_deprecated,
String password); @Override StatusResult startCollector(boolean isCommandLine, String folderToSaveTrace,
VideoOption videoOption_deprecated, boolean isLiveViewVideo, String deviceId,
Hashtable<String, Object> extraParams, String password); void cleanARO(); @Override boolean isTrafficCaptureRunning(int milliSeconds); boolean isVpnActivated(); @Override StatusResult stopCollector(); @Override void timeOutShutdown(); @Override void haltCollectorInDevice(); @Override String getPassword(); @Override boolean setPassword(String requestPassword); @Override String[] getDeviceSerialNumber(StatusResult status); @Override IAroDevice[] getDevices(StatusResult status); @Override boolean isDeviceDataPulled(); }
|
@Ignore @Test public void startCollectorTest(){ Hashtable<String, Object> extranalParams = new Hashtable<String, Object>(); Mockito.when(fileManager.directoryExistAndNotEmpty(Mockito.anyString())).thenReturn(true); StatusResult sResult= null; sResult = nonRootedAndroidCollector.startCollector(true, "test", VideoOption.NONE, false, "testDeice", extranalParams, null); assertEquals(402, sResult.getError().getCode()); Mockito.when(fileManager.directoryExistAndNotEmpty(Mockito.anyString())).thenReturn(false); Mockito.doNothing().when(fileManager).mkDir(Mockito.anyString()); Mockito.when(fileManager.directoryExist(Mockito.anyString())).thenReturn(false); sResult = nonRootedAndroidCollector.startCollector(true, "test", VideoOption.NONE, false, "testDeice", extranalParams, null); assertEquals(406, sResult.getError().getCode()); Mockito.when(fileManager.directoryExist(Mockito.anyString())).thenReturn(true); IDevice aDevice1 = Mockito.mock(IDevice.class); Mockito.when(aDevice1.getSerialNumber()).thenReturn("device1"); IDevice[] devices = {aDevice1}; IDevice[] returnDevices = {}; try { Mockito.when(adbService.getConnectedDevices()).thenReturn(returnDevices); } catch (Exception exp) { exp.printStackTrace(); } sResult = nonRootedAndroidCollector.startCollector(true, "test", VideoOption.NONE, false, "testDeice", extranalParams, null); assertEquals(403, sResult.getError().getCode()); try { Mockito.when(adbService.getConnectedDevices()).thenReturn(devices); } catch (Exception exp) { exp.printStackTrace(); } sResult = nonRootedAndroidCollector.startCollector(true, "test", VideoOption.NONE, false, "testDeice", extranalParams, null); assertEquals(404, sResult.getError().getCode()); Mockito.when(android.removeEmulatorData(Mockito.any(IDevice.class), Mockito.anyString())).thenReturn(true); Mockito.when(android.makeDirectory(Mockito.any(IDevice.class), Mockito.anyString())).thenReturn(true); String[] str1 = {}; Mockito.when(android.getShellReturn(Mockito.any(IDevice.class), Mockito.anyString())).thenReturn(str1); Mockito.when(fileManager.fileExist(Mockito.anyString())).thenReturn(true); Mockito.when(android.runApkInDevice(Mockito.any(IDevice.class),Mockito.anyString())).thenReturn(false); sResult = nonRootedAndroidCollector.startCollector(true, "test", VideoOption.NONE, false, "device1", extranalParams, null); assertEquals(405, sResult.getError().getCode()); Mockito.when(fileManager.fileExist(Mockito.anyString())).thenReturn(false); Mockito.when(extractor.extractFiles(Mockito.anyString(), Mockito.anyString(), Mockito.any(ClassLoader.class))).thenReturn(false); sResult = nonRootedAndroidCollector.startCollector(true, "test", VideoOption.NONE, false, "device1", extranalParams, null); assertEquals(401, sResult.getError().getCode()); Mockito.when(android.getShellReturn(Mockito.any(IDevice.class), Mockito.anyString())).thenReturn(noVpnCon); Mockito.when(fileManager.fileExist(Mockito.anyString())).thenReturn(true); Mockito.when(android.runApkInDevice(Mockito.any(IDevice.class),Mockito.anyString())).thenReturn(true); Mockito.when(android.getShellReturn(Mockito.any(IDevice.class), Mockito.anyString())).thenReturn(noVpnCon).thenReturn(vpnActive); sResult = nonRootedAndroidCollector.startCollector(true, "test", VideoOption.NONE, false, "device1", extranalParams, null); assertTrue(sResult.isSuccess()); Mockito.when(android.getShellReturn(Mockito.any(IDevice.class), Mockito.anyString())).thenReturn(vpnActive).thenReturn(noVpnCon); nonRootedAndroidCollector.stopRunning(); Mockito.when(android.getShellReturn(Mockito.any(IDevice.class), Mockito.anyString())).thenReturn(noVpnCon).thenReturn(vpnActive); sResult = nonRootedAndroidCollector.startCollector(true, "test", VideoOption.NONE, null); assertTrue(sResult.isSuccess()); nonRootedAndroidCollector.stopRunning(); try { Mockito.doNothing().when(videoCapture).init(Mockito.any(IDevice.class), Mockito.anyString()); Mockito.doNothing().when(videoCapture).addSubscriber(Mockito.any(IVideoImageSubscriber.class)); Mockito.doNothing().when(threadExecutor).execute(Mockito.any(IVideoCapture.class)); } catch (IOException e) { e.printStackTrace(); } Mockito.when(android.getShellReturn(Mockito.any(IDevice.class), Mockito.anyString())).thenReturn(noVpnCon).thenReturn(vpnActive); sResult = nonRootedAndroidCollector.startCollector(true, "test", VideoOption.LREZ, false, "device1", extranalParams, null); assertTrue(sResult.isSuccess()); nonRootedAndroidCollector.stopRunning(); try { Mockito.when(adbService.getConnectedDevices()).thenThrow(new Exception("AndroidDebugBridge failed to start")); } catch (Exception exp) { exp.printStackTrace(); } Mockito.when(android.getShellReturn(Mockito.any(IDevice.class), Mockito.anyString())).thenReturn(noVpnCon).thenReturn(vpnActive); sResult = nonRootedAndroidCollector.startCollector(true, "test", VideoOption.LREZ, false, "device1", extranalParams, null); assertEquals(400, sResult.getError().getCode()); }
|
Util { public static String wrapPasswordForEcho(String password) { if (password == null) { return ""; } return "$'" + password.replace("\\", "\\x5c").replace("!", "\\x21").replace("'", "\\x27") + "'"; } static boolean isMacOS(); static boolean isWindowsOS(); static boolean isWindows32OS(); static boolean isWindows64OS(); static boolean isLinuxOS(); static String getAppPath(); static String getMethod(); static String getAROTraceDirIOS(); @Deprecated static String getAroLibrary(); static String getVideoOptimizerLibrary(); static String getExtractedDrivers(); static String getAROTraceDirAndroid(); static String getCurrentRunningDir(); static String escapeRegularExpressionChar(String str); static String getDefaultAppName(String appName); static String getDefaultString(String str, String defaultStr); static Boolean isEmptyIsBlank(String str); static double normalizeTime(double time, double pcapTime); static long parseForUTC(String creationTime, String sdFormatStr); static long parseForUTC(String creationTime); static String formatYMD(long timestamp); static String formatHHMMSS(int seconds); static double convertTime(String time); static String byteArrayToString(byte[] recPayload); static String byteArrayToString(byte[] recPayload, int len); static String condenseStringArray(String[] stringArray); static String byteArrayToHex(byte[] bArray); static Date readHttpDate(String value, boolean defaultForExpired); static String makeLibFilesFromJar(String filename); static String makeLibFolder(String filename, File libFolder); static boolean makeLibFile(String filename, String targetLibFolder, InputStream is); static boolean loadSystemLibrary(String filename); static boolean loadLibrary(String filename, String targetLibFolder); static String formatDecimal(BigDecimal number, int maxFractionDigits, int minFractionDigits); static String getBinPath(); static String getDumpCap(); static String getFFMPEG(); static String getFFPROBE(); static String getIfuse(); static String getEditCap(); static boolean isJPG(File imgfile, String imgExtn); static double doubleFileSize(double mdataSize); static String extractFullNameFromRequest(HttpRequestResponseInfo hrri); static Comparator<String> getDomainSorter(); static Comparator<Integer> getDomainIntSorter(); static BPResultType checkPassFailorWarning(int resultSize, int warning, int fail); static BPResultType checkPassFailorWarning(double resultValue, double warning, double fail); static BPResultType checkPassFailorWarning(double resultValue, double warning); static Level getLoggingLvl(String loggingLvl); static void setLoggingLevel(String logginglevel); static void setLoggingLevel(Level loggingLevel); static String getLoggingLevel(); static boolean isTestMode(); static Comparator<String> getFloatSorter(); static String getIdeviceScreenshot(); static String percentageFormat(double inputValue); static String extractFullNameFromLink(String objName); static String parseImageName(String originalImage, HttpRequestResponseInfo reqResp); static String extractFrameToPNG(double timestamp, String videoPath, String ximagePath); static String validateInputLink(String inputValue); static String escapeChars(String inputValue); static Map<String, String> getRecentOpenMenuItems(); static String[] getRecentlyOpenedTraces(); static String wrapPasswordForEcho(String password); static String wrapText(String path); static void updateRecentItem(String traceDirectory); static boolean isFilesforAnalysisAvailable(File folderPath); static boolean hasTrafficFile(File traceFile); static String formatDouble(double toFormat); static String formatDoubleToMicro(double toFormat); static final String DUMPCAP; static final String FFMPEG; static final String RECENT_TRACES; static final String FFPROBE; static final String IDEVICESCREENSHOT; static final String OS_NAME; static final String OS_VERSION; static final String OS_ARCHITECTURE; static final String FILE_SEPARATOR; static final String LINE_SEPARATOR; static final String TEMP_DIR; }
|
@Test public void testWrapPasswordForEcho() throws Exception { String raw = "\\one!two$three'four"; String converted = "$'\\x5cone\\x21two$three\\x27four'"; String result = Util.wrapPasswordForEcho(raw); assertEquals(converted, result); }
|
ForwardSecrecyUtil { public static boolean containsKey(String cipherHex) { return hexToIdentifier.containsKey(cipherHex); } static void init(); static boolean containsKey(String cipherHex); static ForwardSecrecyBlackList getCipherIdentifier(String cipherHex); }
|
@Test public void testContainsKey() { assertTrue(ForwardSecrecyUtil.containsKey("0x0004")); }
@Test public void testNotContainsKey() { assertNotEquals(true, ForwardSecrecyUtil.containsKey("0xc001")); }
|
ForwardSecrecyUtil { public static ForwardSecrecyBlackList getCipherIdentifier(String cipherHex) { return hexToIdentifier.get(cipherHex); } static void init(); static boolean containsKey(String cipherHex); static ForwardSecrecyBlackList getCipherIdentifier(String cipherHex); }
|
@Test public void testGetCipherIdentifier() { ForwardSecrecyBlackList cipher = ForwardSecrecyUtil.getCipherIdentifier("0x0004"); assertEquals(ForwardSecrecyBlackList.RSA_WITH_RC4_128_MD5, cipher); }
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.