src_fm_fc_ms_ff
stringlengths 43
86.8k
| target
stringlengths 20
276k
|
|---|---|
PriorityProperty { public T getValue() { return finalValue; } @SuppressWarnings("unchecked") PriorityProperty(Type type, T invalidValue, T defaultValue, String... priorityKeys); String[] getPriorityKeys(); T getDefaultValue(); DynamicProperty[] getProperties(); T getValue(); void setCallback(BiConsumer<T, Object> callback, Object target); } | @Test public void testLong() { PriorityProperty<Long> config = priorityPropertyManager.createPriorityProperty(Long.class, -1L, -2L, keys); Assert.assertEquals(-2L, (long) config.getValue()); ArchaiusUtils.setProperty(low, 1L); Assert.assertEquals(1L, (long) config.getValue()); ArchaiusUtils.setProperty(middle, 2L); Assert.assertEquals(2L, (long) config.getValue()); ArchaiusUtils.setProperty(high, 3L); Assert.assertEquals(3L, (long) config.getValue()); ArchaiusUtils.setProperty(middle, null); Assert.assertEquals(3L, (long) config.getValue()); ArchaiusUtils.setProperty(middle, 2L); ArchaiusUtils.setProperty(high, null); Assert.assertEquals(2L, (long) config.getValue()); ArchaiusUtils.setProperty(middle, null); Assert.assertEquals(1L, (long) config.getValue()); ArchaiusUtils.setProperty(low, null); Assert.assertEquals(-2L, (long) config.getValue()); }
@Test public void testInt() { PriorityProperty<Integer> config = priorityPropertyManager.createPriorityProperty(Integer.class, -1, -2, keys); Assert.assertEquals(-2L, (int) config.getValue()); ArchaiusUtils.setProperty(low, 1); Assert.assertEquals(1, (int) config.getValue()); ArchaiusUtils.setProperty(middle, 2); Assert.assertEquals(2, (int) config.getValue()); ArchaiusUtils.setProperty(high, 3); Assert.assertEquals(3, (int) config.getValue()); ArchaiusUtils.setProperty(middle, null); Assert.assertEquals(3, (int) config.getValue()); ArchaiusUtils.setProperty(middle, 2); ArchaiusUtils.setProperty(high, null); Assert.assertEquals(2, (int) config.getValue()); ArchaiusUtils.setProperty(middle, null); Assert.assertEquals(1, (int) config.getValue()); ArchaiusUtils.setProperty(low, null); Assert.assertEquals(-2, (int) config.getValue()); }
@Test public void testString() { PriorityProperty<String> config = priorityPropertyManager.createPriorityProperty(String.class, null, "def", keys); Assert.assertEquals("def", config.getValue()); ArchaiusUtils.setProperty(low, 1); Assert.assertEquals("1", config.getValue()); ArchaiusUtils.setProperty(middle, 2); Assert.assertEquals("2", config.getValue()); ArchaiusUtils.setProperty(high, 3); Assert.assertEquals("3", config.getValue()); ArchaiusUtils.setProperty(middle, null); Assert.assertEquals("3", config.getValue()); ArchaiusUtils.setProperty(middle, 2); ArchaiusUtils.setProperty(high, null); Assert.assertEquals("2", config.getValue()); ArchaiusUtils.setProperty(middle, null); Assert.assertEquals("1", config.getValue()); ArchaiusUtils.setProperty(low, null); Assert.assertEquals("def", config.getValue()); }
@Test public void testBoolean() { PriorityProperty<Boolean> config = priorityPropertyManager.createPriorityProperty(Boolean.class, null, false, keys); Assert.assertFalse(config.getValue()); ArchaiusUtils.setProperty(low, true); Assert.assertTrue(config.getValue()); ArchaiusUtils.setProperty(middle, false); Assert.assertFalse(config.getValue()); ArchaiusUtils.setProperty(high, true); Assert.assertTrue(config.getValue()); ArchaiusUtils.setProperty(middle, false); Assert.assertTrue(config.getValue()); ArchaiusUtils.setProperty(middle, false); ArchaiusUtils.setProperty(high, null); Assert.assertFalse(config.getValue()); ArchaiusUtils.setProperty(middle, null); Assert.assertTrue(config.getValue()); ArchaiusUtils.setProperty(low, null); Assert.assertFalse(config.getValue()); }
@Test public void testDouble() { PriorityProperty<Double> config = priorityPropertyManager.createPriorityProperty(Double.class, null, -2.0, keys); Assert.assertEquals(-2, config.getValue(), 0); ArchaiusUtils.setProperty(low, 1); Assert.assertEquals(1, config.getValue(), 0); ArchaiusUtils.setProperty(middle, 2); Assert.assertEquals(2, config.getValue(), 0); ArchaiusUtils.setProperty(high, 3); Assert.assertEquals(3, config.getValue(), 0); ArchaiusUtils.setProperty(middle, null); Assert.assertEquals(3, config.getValue(), 0); ArchaiusUtils.setProperty(middle, 2); ArchaiusUtils.setProperty(high, null); Assert.assertEquals(2, config.getValue(), 0); ArchaiusUtils.setProperty(middle, null); Assert.assertEquals(1, config.getValue(), 0); ArchaiusUtils.setProperty(low, null); Assert.assertEquals(-2, config.getValue(), 0); }
@Test public void testFloat() { PriorityProperty<Float> config = priorityPropertyManager.createPriorityProperty(Float.class, null, -2.0f, keys); Assert.assertEquals(-2, config.getValue(), 0); ArchaiusUtils.setProperty(low, 1); Assert.assertEquals(1, config.getValue(), 0); ArchaiusUtils.setProperty(middle, 2); Assert.assertEquals(2, config.getValue(), 0); ArchaiusUtils.setProperty(high, 3); Assert.assertEquals(3, config.getValue(), 0); ArchaiusUtils.setProperty(middle, null); Assert.assertEquals(3, config.getValue(), 0); ArchaiusUtils.setProperty(middle, 2); ArchaiusUtils.setProperty(high, null); Assert.assertEquals(2, config.getValue(), 0); ArchaiusUtils.setProperty(middle, null); Assert.assertEquals(1, config.getValue(), 0); ArchaiusUtils.setProperty(low, null); Assert.assertEquals(-2, config.getValue(), 0); }
@Test public void globalRefresh() { PriorityProperty<String> property = priorityPropertyManager.createPriorityProperty(String.class, null, null, keys); Assert.assertNull(property.getValue()); ConcurrentCompositeConfiguration config = (ConcurrentCompositeConfiguration) DynamicPropertyFactory .getBackingConfigurationSource(); config.addConfiguration(new MapConfiguration(Collections.singletonMap(high, "high-value"))); Assert.assertEquals("high-value", property.getValue()); } |
ServiceRegistryClientImpl implements ServiceRegistryClient { @Override public Microservice getAggregatedMicroservice(String microserviceId) { return doGetMicroservice(microserviceId, true); } ServiceRegistryClientImpl(ServiceRegistryConfig serviceRegistryConfig); @Override void init(); @Override List<Microservice> getAllMicroservices(); @Override String getMicroserviceId(String appId, String microserviceName, String versionRule, String environment); @Override boolean isSchemaExist(String microserviceId, String schemaId); @Override boolean registerSchema(String microserviceId, String schemaId, String schemaContent); @Override String getSchema(String microserviceId, String schemaId); @Override String getAggregatedSchema(String microserviceId, String schemaId); @Override Holder<List<GetSchemaResponse>> getSchemas(String microserviceId); @Override String registerMicroservice(Microservice microservice); @Override Microservice getMicroservice(String microserviceId); @Override Microservice getAggregatedMicroservice(String microserviceId); @Override String registerMicroserviceInstance(MicroserviceInstance instance); @Override List<MicroserviceInstance> getMicroserviceInstance(String consumerId, String providerId); @Override boolean unregisterMicroserviceInstance(String microserviceId, String microserviceInstanceId); @Override HeartbeatResponse heartbeat(String microserviceId, String microserviceInstanceId); void watch(String selfMicroserviceId, AsyncResultCallback<MicroserviceInstanceChangedEvent> callback); void watch(String selfMicroserviceId, AsyncResultCallback<MicroserviceInstanceChangedEvent> callback,
AsyncResultCallback<Void> onOpen, AsyncResultCallback<Void> onClose); @Override List<MicroserviceInstance> findServiceInstance(String consumerId, String appId, String serviceName,
String versionRule); @Override MicroserviceInstances findServiceInstances(String consumerId, String appId, String serviceName,
String versionRule, String revision); @Override boolean updateMicroserviceProperties(String microserviceId, Map<String, String> serviceProperties); @Override boolean updateInstanceProperties(String microserviceId, String microserviceInstanceId,
Map<String, String> instanceProperties); @Override MicroserviceInstance findServiceInstance(String serviceId, String instanceId); @Override ServiceCenterInfo getServiceCenterInfo(); @Override boolean updateMicroserviceInstanceStatus(String microserviceId, String instanceId,
MicroserviceInstanceStatus status); @Subscribe void onMicroserviceHeartbeatTask(MicroserviceInstanceHeartbeatTask event); } | @Test public void getAggregatedMicroservice() { String microserviceId = "msId"; new MockUp<RestClientUtil>() { @Mock void httpDo(RequestContext requestContext, Handler<RestResponse> responseHandler) { Holder<GetServiceResponse> holder = Deencapsulation.getField(responseHandler, "arg$4"); holder.value = Json .decodeValue( "{\"service\":{\"serviceId\":\"serviceId\",\"framework\":null" + ",\"registerBy\":null,\"environment\":null,\"appId\":\"appId\",\"serviceName\":null," + "\"alias\":null,\"version\":null,\"description\":null,\"level\":null,\"schemas\":[]," + "\"paths\":[],\"status\":\"UP\",\"properties\":{},\"intance\":null}}", GetServiceResponse.class); RequestParam requestParam = requestContext.getParams(); Assert.assertEquals("global=true", requestParam.getQueryParams()); } }; Microservice aggregatedMicroservice = oClient.getAggregatedMicroservice(microserviceId); Assert.assertEquals("serviceId", aggregatedMicroservice.getServiceId()); Assert.assertEquals("appId", aggregatedMicroservice.getAppId()); } |
MetricsBootListener implements BootListener { @Override public void onBeforeProducerProvider(BootEvent event) { if (!DynamicPropertyFactory.getInstance().getBooleanProperty("servicecomb.metrics.endpoint.enabled", true).get()) { return; } MetricsRestPublisher metricsRestPublisher = SPIServiceUtils.getTargetService(MetricsInitializer.class, MetricsRestPublisher.class); event.getScbEngine().getProducerProviderManager() .addProducerMeta("metricsEndpoint", metricsRestPublisher); } MetricsBootstrap getMetricsBootstrap(); SlowInvocationLogger getSlowInvocationLogger(); @Override void onBeforeProducerProvider(BootEvent event); @Override void onAfterRegistry(BootEvent event); @Override void onBeforeClose(BootEvent event); } | @Test public void onBeforeProducerProvider_metrics_endpoint_enabled_by_default() { final MetricsBootListener listener = new MetricsBootListener(); final List<ProducerMeta> producerMetas = new ArrayList<>(); final BootEvent event = new BootEvent(); final ProducerMeta producerMeta = new ProducerMeta(); final SCBEngine scbEngine = new SCBEngine() { final public ProducerProviderManager producerProviderManager = new ProducerProviderManager(this) { @Override public void addProducerMeta(String schemaId, Object instance) { producerMeta.setSchemaId(schemaId); producerMeta.setInstance(instance); producerMetas.add(producerMeta); } }; @Override public ProducerProviderManager getProducerProviderManager() { return producerProviderManager; } }; event.setScbEngine(scbEngine); listener.onBeforeProducerProvider(event); Assert.assertThat(producerMetas, Matchers.contains(producerMeta)); Assert.assertThat(producerMeta.getSchemaId(), Matchers.equalTo("metricsEndpoint")); Assert.assertThat(producerMeta.getInstance(), Matchers.instanceOf(MetricsRestPublisher.class)); }
@Test public void onBeforeProducerProvider_metrics_endpoint_disabled() { ArchaiusUtils.setProperty("servicecomb.metrics.endpoint.enabled", false); final MetricsBootListener listener = new MetricsBootListener(); final List<ProducerMeta> producerMetas = new ArrayList<>(); final BootEvent event = new BootEvent(); final SCBEngine scbEngine = new SCBEngine() { final public ProducerProviderManager producerProviderManager = new ProducerProviderManager(this) { @Override public void addProducerMeta(String schemaId, Object instance) { producerMetas.add(new ProducerMeta(schemaId, instance)); } }; @Override public ProducerProviderManager getProducerProviderManager() { return producerProviderManager; } }; event.setScbEngine(scbEngine); listener.onBeforeProducerProvider(event); Assert.assertThat(producerMetas, Matchers.empty()); } |
ConfigUtil { public static void addConfig(String key, Object value) { localConfig.put(key, value); } private ConfigUtil(); static void setConfigs(Map<String, Object> config); static void addConfig(String key, Object value); static Object getProperty(String key); static Object getProperty(Object config, String key); static List<String> getStringList(@Nonnull Configuration config, @Nonnull String key); static MicroserviceConfigLoader getMicroserviceConfigLoader(); static MicroserviceConfigLoader getMicroserviceConfigLoader(Configuration config); static ConcurrentCompositeConfiguration createLocalConfig(); static AbstractConfiguration convertEnvVariable(AbstractConfiguration source); static AbstractConfiguration createDynamicConfig(); static void installDynamicConfig(); static void destroyConfigCenterConfigurationSource(); static void addExtraConfig(String extraConfigName, Map<String, Object> extraConfig); static void clearExtraConfig(); @SuppressWarnings("unchecked") static ConcurrentHashMap<String, DynamicProperty> getAllDynamicProperties(); @SuppressWarnings("unchecked") static CopyOnWriteArraySet<Runnable> getCallbacks(DynamicProperty property); } | @Test public void testAddConfig() { Map<String, Object> config = new HashMap<>(); config.put("service_description.name", "service_name_test"); ConfigUtil.setConfigs(config); ConfigUtil.addConfig("service_description.version", "1.0.2"); ConfigUtil.addConfig("cse.test.enabled", true); ConfigUtil.addConfig("cse.test.num", 10); AbstractConfiguration configuration = ConfigUtil.createDynamicConfig(); Assert.assertEquals(configuration.getString("service_description.name"), "service_name_test"); Assert.assertTrue(configuration.getBoolean("cse.test.enabled")); Assert.assertEquals(configuration.getInt("cse.test.num"), 10); } |
ConfigUtil { public static AbstractConfiguration createDynamicConfig() { ConcurrentCompositeConfiguration compositeConfig = ConfigUtil.createLocalConfig(); ConfigCenterConfigurationSource configCenterConfigurationSource = createConfigCenterConfigurationSource(compositeConfig); if (configCenterConfigurationSource != null) { createDynamicWatchedConfiguration(compositeConfig, configCenterConfigurationSource); } return compositeConfig; } private ConfigUtil(); static void setConfigs(Map<String, Object> config); static void addConfig(String key, Object value); static Object getProperty(String key); static Object getProperty(Object config, String key); static List<String> getStringList(@Nonnull Configuration config, @Nonnull String key); static MicroserviceConfigLoader getMicroserviceConfigLoader(); static MicroserviceConfigLoader getMicroserviceConfigLoader(Configuration config); static ConcurrentCompositeConfiguration createLocalConfig(); static AbstractConfiguration convertEnvVariable(AbstractConfiguration source); static AbstractConfiguration createDynamicConfig(); static void installDynamicConfig(); static void destroyConfigCenterConfigurationSource(); static void addExtraConfig(String extraConfigName, Map<String, Object> extraConfig); static void clearExtraConfig(); @SuppressWarnings("unchecked") static ConcurrentHashMap<String, DynamicProperty> getAllDynamicProperties(); @SuppressWarnings("unchecked") static CopyOnWriteArraySet<Runnable> getCallbacks(DynamicProperty property); } | @Test public void testCreateDynamicConfigHasConfigCenter() { AbstractConfiguration dynamicConfig = ConfigUtil.createDynamicConfig(); Assert.assertEquals(DynamicWatchedConfiguration.class, ((ConcurrentCompositeConfiguration) dynamicConfig).getConfiguration(0).getClass()); } |
ConfigUtil { public static Object getProperty(String key) { Object config = DynamicPropertyFactory.getBackingConfigurationSource(); return getProperty(config, key); } private ConfigUtil(); static void setConfigs(Map<String, Object> config); static void addConfig(String key, Object value); static Object getProperty(String key); static Object getProperty(Object config, String key); static List<String> getStringList(@Nonnull Configuration config, @Nonnull String key); static MicroserviceConfigLoader getMicroserviceConfigLoader(); static MicroserviceConfigLoader getMicroserviceConfigLoader(Configuration config); static ConcurrentCompositeConfiguration createLocalConfig(); static AbstractConfiguration convertEnvVariable(AbstractConfiguration source); static AbstractConfiguration createDynamicConfig(); static void installDynamicConfig(); static void destroyConfigCenterConfigurationSource(); static void addExtraConfig(String extraConfigName, Map<String, Object> extraConfig); static void clearExtraConfig(); @SuppressWarnings("unchecked") static ConcurrentHashMap<String, DynamicProperty> getAllDynamicProperties(); @SuppressWarnings("unchecked") static CopyOnWriteArraySet<Runnable> getCallbacks(DynamicProperty property); } | @Test public void testGetPropertyInvalidConfig() { Assert.assertNull(ConfigUtil.getProperty(null, "any")); Assert.assertNull(ConfigUtil.getProperty(new Object(), "any")); }
@Test public void duplicateServiceCombConfigToCseListValue() { List<String> list = Arrays.asList("a", "b"); AbstractConfiguration config = new DynamicConfiguration(); config.addProperty("cse.list", list); Deencapsulation.invoke(ConfigUtil.class, "duplicateCseConfigToServicecomb", config); Object result = config.getProperty("servicecomb.list"); assertThat(result, instanceOf(List.class)); assertThat(result, equalTo(list)); } |
ServiceRegistryClientImpl implements ServiceRegistryClient { @Override public String getAggregatedSchema(String microserviceId, String schemaId) { return doGetSchema(microserviceId, schemaId, true); } ServiceRegistryClientImpl(ServiceRegistryConfig serviceRegistryConfig); @Override void init(); @Override List<Microservice> getAllMicroservices(); @Override String getMicroserviceId(String appId, String microserviceName, String versionRule, String environment); @Override boolean isSchemaExist(String microserviceId, String schemaId); @Override boolean registerSchema(String microserviceId, String schemaId, String schemaContent); @Override String getSchema(String microserviceId, String schemaId); @Override String getAggregatedSchema(String microserviceId, String schemaId); @Override Holder<List<GetSchemaResponse>> getSchemas(String microserviceId); @Override String registerMicroservice(Microservice microservice); @Override Microservice getMicroservice(String microserviceId); @Override Microservice getAggregatedMicroservice(String microserviceId); @Override String registerMicroserviceInstance(MicroserviceInstance instance); @Override List<MicroserviceInstance> getMicroserviceInstance(String consumerId, String providerId); @Override boolean unregisterMicroserviceInstance(String microserviceId, String microserviceInstanceId); @Override HeartbeatResponse heartbeat(String microserviceId, String microserviceInstanceId); void watch(String selfMicroserviceId, AsyncResultCallback<MicroserviceInstanceChangedEvent> callback); void watch(String selfMicroserviceId, AsyncResultCallback<MicroserviceInstanceChangedEvent> callback,
AsyncResultCallback<Void> onOpen, AsyncResultCallback<Void> onClose); @Override List<MicroserviceInstance> findServiceInstance(String consumerId, String appId, String serviceName,
String versionRule); @Override MicroserviceInstances findServiceInstances(String consumerId, String appId, String serviceName,
String versionRule, String revision); @Override boolean updateMicroserviceProperties(String microserviceId, Map<String, String> serviceProperties); @Override boolean updateInstanceProperties(String microserviceId, String microserviceInstanceId,
Map<String, String> instanceProperties); @Override MicroserviceInstance findServiceInstance(String serviceId, String instanceId); @Override ServiceCenterInfo getServiceCenterInfo(); @Override boolean updateMicroserviceInstanceStatus(String microserviceId, String instanceId,
MicroserviceInstanceStatus status); @Subscribe void onMicroserviceHeartbeatTask(MicroserviceInstanceHeartbeatTask event); } | @Test public void getAggregatedSchema() { String microserviceId = "msId"; String schemaId = "schemaId"; new MockUp<RestClientUtil>() { @Mock void httpDo(RequestContext requestContext, Handler<RestResponse> responseHandler) { Holder<GetSchemaResponse> holder = Deencapsulation.getField(responseHandler, "arg$4"); holder.value = Json .decodeValue( "{ \"schema\": \"schema\", \"schemaId\":\"metricsEndpoint\",\"summary\":\"c1188d709631a9038874f9efc6eb894f\"}", GetSchemaResponse.class); RequestParam requestParam = requestContext.getParams(); Assert.assertEquals("global=true", requestParam.getQueryParams()); } }; LoadingCache<String, Map<String, String>> oldCache = Deencapsulation.getField(oClient, "schemaCache"); LoadingCache<String, Map<String, String>> newCache = CacheBuilder.newBuilder() .expireAfterAccess(60, TimeUnit.SECONDS).build(new CacheLoader<String, Map<String, String>>() { public Map<String, String> load(String key) { Map<String, String> schemas = new HashMap<>(); return schemas; } }); Deencapsulation.setField(oClient, "schemaCache", newCache); String str = oClient.getAggregatedSchema(microserviceId, schemaId); Assert.assertEquals("schema", str); Deencapsulation.setField(oClient, "schemaCache", oldCache); } |
ConfigUtil { public static AbstractConfiguration convertEnvVariable(AbstractConfiguration source) { Iterator<String> keys = source.getKeys(); while (keys.hasNext()) { String key = keys.next(); String[] separatedKey = key.split(CONFIG_KEY_SPLITER); if (separatedKey.length == 1) { continue; } String newKey = String.join(".", separatedKey); source.addProperty(newKey, source.getProperty(key)); } return source; } private ConfigUtil(); static void setConfigs(Map<String, Object> config); static void addConfig(String key, Object value); static Object getProperty(String key); static Object getProperty(Object config, String key); static List<String> getStringList(@Nonnull Configuration config, @Nonnull String key); static MicroserviceConfigLoader getMicroserviceConfigLoader(); static MicroserviceConfigLoader getMicroserviceConfigLoader(Configuration config); static ConcurrentCompositeConfiguration createLocalConfig(); static AbstractConfiguration convertEnvVariable(AbstractConfiguration source); static AbstractConfiguration createDynamicConfig(); static void installDynamicConfig(); static void destroyConfigCenterConfigurationSource(); static void addExtraConfig(String extraConfigName, Map<String, Object> extraConfig); static void clearExtraConfig(); @SuppressWarnings("unchecked") static ConcurrentHashMap<String, DynamicProperty> getAllDynamicProperties(); @SuppressWarnings("unchecked") static CopyOnWriteArraySet<Runnable> getCallbacks(DynamicProperty property); } | @Test public void testConvertEnvVariable() { String someProperty = "cse_service_registry_address"; AbstractConfiguration config = new DynamicConfiguration(); config.addProperty(someProperty, "testing"); AbstractConfiguration result = ConfigUtil.convertEnvVariable(config); assertThat(result.getString("cse.service.registry.address"), equalTo("testing")); assertThat(result.getString("cse_service_registry_address"), equalTo("testing")); } |
ConfigUtil { public static void destroyConfigCenterConfigurationSource() { SPIServiceUtils.getAllService(ConfigCenterConfigurationSource.class).forEach(source -> { try { source.destroy(); } catch (Throwable e) { LOGGER.error("Failed to destroy {}", source.getClass().getName()); } }); } private ConfigUtil(); static void setConfigs(Map<String, Object> config); static void addConfig(String key, Object value); static Object getProperty(String key); static Object getProperty(Object config, String key); static List<String> getStringList(@Nonnull Configuration config, @Nonnull String key); static MicroserviceConfigLoader getMicroserviceConfigLoader(); static MicroserviceConfigLoader getMicroserviceConfigLoader(Configuration config); static ConcurrentCompositeConfiguration createLocalConfig(); static AbstractConfiguration convertEnvVariable(AbstractConfiguration source); static AbstractConfiguration createDynamicConfig(); static void installDynamicConfig(); static void destroyConfigCenterConfigurationSource(); static void addExtraConfig(String extraConfigName, Map<String, Object> extraConfig); static void clearExtraConfig(); @SuppressWarnings("unchecked") static ConcurrentHashMap<String, DynamicProperty> getAllDynamicProperties(); @SuppressWarnings("unchecked") static CopyOnWriteArraySet<Runnable> getCallbacks(DynamicProperty property); } | @Test public void destroyConfigCenterConfigurationSource() { AtomicInteger count = new AtomicInteger(); ConfigCenterConfigurationSource source = new MockUp<ConfigCenterConfigurationSource>() { @Mock void destroy() { count.incrementAndGet(); } }.getMockInstance(); new Expectations(SPIServiceUtils.class) { { SPIServiceUtils.getAllService(ConfigCenterConfigurationSource.class); result = Arrays.asList(source, source); } }; ConfigUtil.destroyConfigCenterConfigurationSource(); Assert.assertEquals(2, count.get()); } |
DiscoveryTree { public void loadFromSPI(Class<? extends DiscoveryFilter> cls) { filters.addAll(SPIServiceUtils.getSortedService(cls)); } void loadFromSPI(Class<? extends DiscoveryFilter> cls); void addFilter(DiscoveryFilter filter); void sort(); DiscoveryTreeNode discovery(DiscoveryContext context, String appId, String microserviceName,
String versionRule); DiscoveryTreeNode discovery(DiscoveryContext context, VersionedCache inputCache); } | @Test public void loadFromSPI(@Mocked DiscoveryFilter f1, @Mocked DiscoveryFilter f2) { Class<? extends DiscoveryFilter> cls = DiscoveryFilter.class; new Expectations(SPIServiceUtils.class) { { SPIServiceUtils.getSortedService(cls); result = Arrays.asList(f1, f2); } }; discoveryTree.loadFromSPI(cls); Assert.assertThat(filters, Matchers.contains(f1, f2)); } |
DiscoveryTree { public void sort() { filters.sort(Comparator.comparingInt(DiscoveryFilter::getOrder)); Iterator<DiscoveryFilter> iterator = filters.iterator(); while (iterator.hasNext()) { DiscoveryFilter filter = iterator.next(); if (!filter.enabled()) { iterator.remove(); } LOGGER.info("DiscoveryFilter {}, enabled {}.", filter.getClass().getName(), filter.enabled()); } } void loadFromSPI(Class<? extends DiscoveryFilter> cls); void addFilter(DiscoveryFilter filter); void sort(); DiscoveryTreeNode discovery(DiscoveryContext context, String appId, String microserviceName,
String versionRule); DiscoveryTreeNode discovery(DiscoveryContext context, VersionedCache inputCache); } | @Test public void sort(@Mocked DiscoveryFilter f1, @Mocked DiscoveryFilter f2, @Mocked DiscoveryFilter f3) { new Expectations() { { f1.getOrder(); result = -1; f1.enabled(); result = true; f2.getOrder(); result = 0; f2.enabled(); result = true; f3.getOrder(); result = 0; f3.enabled(); result = false; } }; discoveryTree.addFilter(f3); discoveryTree.addFilter(f2); discoveryTree.addFilter(f1); discoveryTree.sort(); Assert.assertThat(filters, Matchers.contains(f1, f2)); } |
DiscoveryTree { protected boolean isMatch(VersionedCache existing, VersionedCache inputCache) { return existing != null && existing.isSameVersion(inputCache); } void loadFromSPI(Class<? extends DiscoveryFilter> cls); void addFilter(DiscoveryFilter filter); void sort(); DiscoveryTreeNode discovery(DiscoveryContext context, String appId, String microserviceName,
String versionRule); DiscoveryTreeNode discovery(DiscoveryContext context, VersionedCache inputCache); } | @Test public void isMatch_existingNull() { Assert.assertFalse(discoveryTree.isMatch(null, null)); }
@Test public void isMatch_yes() { parent.cacheVersion(1); Assert.assertTrue(discoveryTree.isMatch(new DiscoveryTreeNode().cacheVersion(1), parent)); } |
DiscoveryTree { protected boolean isExpired(VersionedCache existing, VersionedCache inputCache) { return existing == null || existing.isExpired(inputCache); } void loadFromSPI(Class<? extends DiscoveryFilter> cls); void addFilter(DiscoveryFilter filter); void sort(); DiscoveryTreeNode discovery(DiscoveryContext context, String appId, String microserviceName,
String versionRule); DiscoveryTreeNode discovery(DiscoveryContext context, VersionedCache inputCache); } | @Test public void isMatch_no() { parent.cacheVersion(0); Assert.assertFalse(discoveryTree.isExpired(new DiscoveryTreeNode().cacheVersion(1), parent)); }
@Test public void isExpired_existingNull() { Assert.assertTrue(discoveryTree.isExpired(null, null)); }
@Test public void isExpired_yes() { parent.cacheVersion(1); Assert.assertTrue(discoveryTree.isExpired(new DiscoveryTreeNode().cacheVersion(0), parent)); }
@Test public void isExpired_no() { parent.cacheVersion(0); Assert.assertFalse(discoveryTree.isExpired(new DiscoveryTreeNode().cacheVersion(0), parent)); } |
ServiceRegistryClientImpl implements ServiceRegistryClient { @Override public Holder<List<GetSchemaResponse>> getSchemas(String microserviceId) { return getSchemas(microserviceId, false, false); } ServiceRegistryClientImpl(ServiceRegistryConfig serviceRegistryConfig); @Override void init(); @Override List<Microservice> getAllMicroservices(); @Override String getMicroserviceId(String appId, String microserviceName, String versionRule, String environment); @Override boolean isSchemaExist(String microserviceId, String schemaId); @Override boolean registerSchema(String microserviceId, String schemaId, String schemaContent); @Override String getSchema(String microserviceId, String schemaId); @Override String getAggregatedSchema(String microserviceId, String schemaId); @Override Holder<List<GetSchemaResponse>> getSchemas(String microserviceId); @Override String registerMicroservice(Microservice microservice); @Override Microservice getMicroservice(String microserviceId); @Override Microservice getAggregatedMicroservice(String microserviceId); @Override String registerMicroserviceInstance(MicroserviceInstance instance); @Override List<MicroserviceInstance> getMicroserviceInstance(String consumerId, String providerId); @Override boolean unregisterMicroserviceInstance(String microserviceId, String microserviceInstanceId); @Override HeartbeatResponse heartbeat(String microserviceId, String microserviceInstanceId); void watch(String selfMicroserviceId, AsyncResultCallback<MicroserviceInstanceChangedEvent> callback); void watch(String selfMicroserviceId, AsyncResultCallback<MicroserviceInstanceChangedEvent> callback,
AsyncResultCallback<Void> onOpen, AsyncResultCallback<Void> onClose); @Override List<MicroserviceInstance> findServiceInstance(String consumerId, String appId, String serviceName,
String versionRule); @Override MicroserviceInstances findServiceInstances(String consumerId, String appId, String serviceName,
String versionRule, String revision); @Override boolean updateMicroserviceProperties(String microserviceId, Map<String, String> serviceProperties); @Override boolean updateInstanceProperties(String microserviceId, String microserviceInstanceId,
Map<String, String> instanceProperties); @Override MicroserviceInstance findServiceInstance(String serviceId, String instanceId); @Override ServiceCenterInfo getServiceCenterInfo(); @Override boolean updateMicroserviceInstanceStatus(String microserviceId, String instanceId,
MicroserviceInstanceStatus status); @Subscribe void onMicroserviceHeartbeatTask(MicroserviceInstanceHeartbeatTask event); } | @Test public void getSchemas() { String microserviceId = "msId"; new MockUp<RestClientUtil>() { @Mock void httpDo(RequestContext requestContext, Handler<RestResponse> responseHandler) { Holder<GetSchemasResponse> holder = Deencapsulation.getField(responseHandler, "arg$4"); GetSchemasResponse schemasResp = Json.decodeValue( "{\"schema\":[{\"schemaId\":\"metricsEndpoint\",\"summary\":\"c1188d709631a9038874f9efc6eb894f\"},{\"schemaId\":\"comment\",\"summary\":\"bfa81d625cfbd3a57f38745323e16824\"}," + "{\"schemaId\":\"healthEndpoint\",\"summary\":\"96a0aaaaa454cfa0c716e70c0017fe27\"}]}", GetSchemasResponse.class); holder.statusCode = 200; holder.value = schemasResp; } }; Holder<List<GetSchemaResponse>> schemasHolder = oClient.getSchemas(microserviceId); List<GetSchemaResponse> schemaResponses = schemasHolder.getValue(); Assert.assertEquals(200, schemasHolder.getStatusCode()); Assert.assertEquals(3, schemaResponses.size()); Assert.assertEquals("bfa81d625cfbd3a57f38745323e16824", schemaResponses.get(1).getSummary()); }
@Test public void getSchemasForNew() { String microserviceId = "msId"; new MockUp<RestClientUtil>() { @Mock void httpDo(RequestContext requestContext, Handler<RestResponse> responseHandler) { Holder<GetSchemasResponse> holder = Deencapsulation.getField(responseHandler, "arg$4"); GetSchemasResponse schemasResp = Json.decodeValue( "{\"schemas\":[{\"schemaId\":\"metricsEndpoint\",\"summary\":\"c1188d709631a9038874f9efc6eb894f\"},{\"schemaId\":\"comment\",\"summary\":\"bfa81d625cfbd3a57f38745323e16824\"}," + "{\"schemaId\":\"healthEndpoint\",\"summary\":\"96a0aaaaa454cfa0c716e70c0017fe27\"}]}", GetSchemasResponse.class); holder.statusCode = 200; holder.value = schemasResp; } }; Holder<List<GetSchemaResponse>> schemasHolder = oClient.getSchemas(microserviceId); List<GetSchemaResponse> schemas = schemasHolder.getValue(); Assert.assertEquals(200, schemasHolder.getStatusCode()); Assert.assertEquals(3, schemas.size()); Assert.assertEquals("bfa81d625cfbd3a57f38745323e16824", schemas.get(1).getSummary()); }
@Test public void getSchemasFailed() { String microserviceId = "msId"; new MockUp<RestClientUtil>() { @Mock void httpDo(RequestContext requestContext, Handler<RestResponse> responseHandler) { Holder<GetSchemasResponse> holder = Deencapsulation.getField(responseHandler, "arg$4"); holder.setStatusCode(Status.NOT_FOUND.getStatusCode()); } }; Holder<List<GetSchemaResponse>> schemasHolder = oClient.getSchemas(microserviceId); List<GetSchemaResponse> schemaResponses = schemasHolder.getValue(); Assert.assertEquals(404, schemasHolder.getStatusCode()); Assert.assertNull(schemaResponses); } |
DiscoveryTree { public DiscoveryTreeNode discovery(DiscoveryContext context, String appId, String microserviceName, String versionRule) { VersionedCache instanceVersionedCache = DiscoveryManager.INSTANCE .getInstanceCacheManager() .getOrCreateVersionedCache(appId, microserviceName, versionRule); return discovery(context, instanceVersionedCache); } void loadFromSPI(Class<? extends DiscoveryFilter> cls); void addFilter(DiscoveryFilter filter); void sort(); DiscoveryTreeNode discovery(DiscoveryContext context, String appId, String microserviceName,
String versionRule); DiscoveryTreeNode discovery(DiscoveryContext context, VersionedCache inputCache); } | @Test public void easyDiscovery(@Mocked InstanceCacheManager instanceCacheManager) { new Expectations(DiscoveryManager.class) { { DiscoveryManager.INSTANCE.getInstanceCacheManager(); result = instanceCacheManager; instanceCacheManager.getOrCreateVersionedCache(anyString, anyString, anyString); result = parent; } }; result = discoveryTree.discovery(context, null, null, null); Assert.assertEquals(parent.name(), result.name()); Assert.assertEquals(parent.cacheVersion(), result.cacheVersion()); }
@Test public void avoidConcurrentProblem() { Deencapsulation.setField(discoveryTree, "root", parent.cacheVersion(1)); Assert.assertTrue(parent.children().isEmpty()); discoveryTree.discovery(context, new VersionedCache().cacheVersion(0).name("input")); Assert.assertTrue(parent.children().isEmpty()); } |
DiscoveryTree { protected DiscoveryTreeNode getOrCreateRoot(VersionedCache inputCache) { DiscoveryTreeNode tmpRoot = root; if (isMatch(tmpRoot, inputCache)) { return tmpRoot; } synchronized (lock) { if (isExpired(root, inputCache)) { root = new DiscoveryTreeNode().cacheVersion(inputCache.cacheVersion()); return root; } if (root.isSameVersion(inputCache)) { return root; } } return new DiscoveryTreeNode().cacheVersion(inputCache.cacheVersion()); } void loadFromSPI(Class<? extends DiscoveryFilter> cls); void addFilter(DiscoveryFilter filter); void sort(); DiscoveryTreeNode discovery(DiscoveryContext context, String appId, String microserviceName,
String versionRule); DiscoveryTreeNode discovery(DiscoveryContext context, VersionedCache inputCache); } | @Test public void getOrCreateRoot_match() { Deencapsulation.setField(discoveryTree, "root", parent); DiscoveryTreeNode root = discoveryTree.getOrCreateRoot(parent); Assert.assertSame(parent, root); }
@Test public void getOrCreateRoot_expired() { Deencapsulation.setField(discoveryTree, "root", parent); VersionedCache inputCache = new VersionedCache().cacheVersion(parent.cacheVersion() + 1); DiscoveryTreeNode root = discoveryTree.getOrCreateRoot(inputCache); Assert.assertEquals(inputCache.cacheVersion(), root.cacheVersion()); Assert.assertSame(Deencapsulation.getField(discoveryTree, "root"), root); }
@Test public void getOrCreateRoot_tempRoot() { Deencapsulation.setField(discoveryTree, "root", parent); VersionedCache inputCache = new VersionedCache().cacheVersion(parent.cacheVersion() - 1); DiscoveryTreeNode root = discoveryTree.getOrCreateRoot(inputCache); Assert.assertEquals(inputCache.cacheVersion(), root.cacheVersion()); Assert.assertNotSame(Deencapsulation.getField(discoveryTree, "root"), root); } |
DiscoveryTreeNode extends VersionedCache { public boolean childrenInited() { return childrenInited; } boolean childrenInited(); DiscoveryTreeNode childrenInited(boolean childrenInited); int level(); DiscoveryTreeNode level(int level); @SuppressWarnings("unchecked") T attribute(String key); DiscoveryTreeNode attribute(String key, Object value); Map<String, DiscoveryTreeNode> children(); DiscoveryTreeNode children(Map<String, DiscoveryTreeNode> children); DiscoveryTreeNode child(String childName); DiscoveryTreeNode child(String childName, DiscoveryTreeNode child); DiscoveryTreeNode fromCache(VersionedCache other); } | @Test public void childrenInited() { Assert.assertFalse(node.childrenInited()); node.childrenInited(true); Assert.assertTrue(node.childrenInited()); } |
DiscoveryTreeNode extends VersionedCache { public int level() { return level; } boolean childrenInited(); DiscoveryTreeNode childrenInited(boolean childrenInited); int level(); DiscoveryTreeNode level(int level); @SuppressWarnings("unchecked") T attribute(String key); DiscoveryTreeNode attribute(String key, Object value); Map<String, DiscoveryTreeNode> children(); DiscoveryTreeNode children(Map<String, DiscoveryTreeNode> children); DiscoveryTreeNode child(String childName); DiscoveryTreeNode child(String childName, DiscoveryTreeNode child); DiscoveryTreeNode fromCache(VersionedCache other); } | @Test public void level() { node.level(1); Assert.assertEquals(1, node.level()); } |
DiscoveryTreeNode extends VersionedCache { @SuppressWarnings("unchecked") public <T> T attribute(String key) { return (T) attributes.get(key); } boolean childrenInited(); DiscoveryTreeNode childrenInited(boolean childrenInited); int level(); DiscoveryTreeNode level(int level); @SuppressWarnings("unchecked") T attribute(String key); DiscoveryTreeNode attribute(String key, Object value); Map<String, DiscoveryTreeNode> children(); DiscoveryTreeNode children(Map<String, DiscoveryTreeNode> children); DiscoveryTreeNode child(String childName); DiscoveryTreeNode child(String childName, DiscoveryTreeNode child); DiscoveryTreeNode fromCache(VersionedCache other); } | @Test public void attribute() { node.attribute("k1", "v1"); Assert.assertEquals("v1", node.attribute("k1")); } |
DiscoveryTreeNode extends VersionedCache { public Map<String, DiscoveryTreeNode> children() { return children; } boolean childrenInited(); DiscoveryTreeNode childrenInited(boolean childrenInited); int level(); DiscoveryTreeNode level(int level); @SuppressWarnings("unchecked") T attribute(String key); DiscoveryTreeNode attribute(String key, Object value); Map<String, DiscoveryTreeNode> children(); DiscoveryTreeNode children(Map<String, DiscoveryTreeNode> children); DiscoveryTreeNode child(String childName); DiscoveryTreeNode child(String childName, DiscoveryTreeNode child); DiscoveryTreeNode fromCache(VersionedCache other); } | @Test public void children() { Map<String, DiscoveryTreeNode> children = new HashMap<>(); node.children(children); Assert.assertSame(children, node.children()); } |
DiscoveryTreeNode extends VersionedCache { public DiscoveryTreeNode child(String childName) { return children.get(childName); } boolean childrenInited(); DiscoveryTreeNode childrenInited(boolean childrenInited); int level(); DiscoveryTreeNode level(int level); @SuppressWarnings("unchecked") T attribute(String key); DiscoveryTreeNode attribute(String key, Object value); Map<String, DiscoveryTreeNode> children(); DiscoveryTreeNode children(Map<String, DiscoveryTreeNode> children); DiscoveryTreeNode child(String childName); DiscoveryTreeNode child(String childName, DiscoveryTreeNode child); DiscoveryTreeNode fromCache(VersionedCache other); } | @Test public void child() { DiscoveryTreeNode child = new DiscoveryTreeNode().name("child"); node.child(child.name(), child); Assert.assertSame(child, node.child(child.name())); } |
DiscoveryTreeNode extends VersionedCache { public DiscoveryTreeNode fromCache(VersionedCache other) { this.cacheVersion = other.cacheVersion(); this.name = other.name(); this.data(other.data()); return this; } boolean childrenInited(); DiscoveryTreeNode childrenInited(boolean childrenInited); int level(); DiscoveryTreeNode level(int level); @SuppressWarnings("unchecked") T attribute(String key); DiscoveryTreeNode attribute(String key, Object value); Map<String, DiscoveryTreeNode> children(); DiscoveryTreeNode children(Map<String, DiscoveryTreeNode> children); DiscoveryTreeNode child(String childName); DiscoveryTreeNode child(String childName, DiscoveryTreeNode child); DiscoveryTreeNode fromCache(VersionedCache other); } | @Test public void fromCache() { Object data = new Object(); VersionedCache other = new VersionedCache().cacheVersion(1).name("cache").data(data); node.fromCache(other); Assert.assertEquals(1, node.cacheVersion()); Assert.assertEquals("cache", node.name()); Assert.assertSame(data, node.data()); } |
AbstractPropertiesLoader { public Map<String, String> loadProperties(Configuration configuration) { Map<String, String> propertiesMap = new HashMap<>(); loadPropertiesFromConfigMap(configuration, propertiesMap); loadPropertiesFromExtendedClass(configuration, propertiesMap); return propertiesMap; } Map<String, String> loadProperties(Configuration configuration); } | @Test public void testExtendedClassCompatible() { Configuration configuration = new DynamicConfiguration(); configuration.setProperty(BootStrapProperties.CONFIG_SERVICE_EXTENDED_CLASS, "invalidClass"); AbstractPropertiesLoader loader = MicroservicePropertiesLoader.INSTANCE; try { loader.loadProperties(configuration); Assert.fail("Must throw exception"); } catch (Error e) { Assert.assertEquals(ClassNotFoundException.class, e.getCause().getClass()); Assert.assertEquals("invalidClass", e.getCause().getMessage()); } } |
VersionRuleRangeParser implements VersionRuleParser { @Override public VersionRule parse(String strVersionRule) { int pos = strVersionRule.indexOf('-'); if (pos <= 0 || pos == strVersionRule.length() - 1) { return null; } Version from = new Version(strVersionRule.substring(0, pos)); Version to = new Version(strVersionRule.substring(pos + 1)); return new RangeVersionRule(from.getVersion() + "-" + to.getVersion(), from, to); } @Override VersionRule parse(String strVersionRule); } | @Test public void parseInvalid() { Assert.assertNull(parser.parse("")); Assert.assertNull(parser.parse("-")); Assert.assertNull(parser.parse("1-")); } |
VersionRule { public boolean isAccept(Version version) { return isMatch(version, null); } VersionRule(String versionRule); String getVersionRule(); boolean isAccept(Version version); abstract boolean isMatch(Version version, Version latestVersion); @Override String toString(); } | @Test public void isAccept() { Assert.assertTrue(versionRule.isAccept(null)); } |
VersionRule { public String getVersionRule() { return versionRule; } VersionRule(String versionRule); String getVersionRule(); boolean isAccept(Version version); abstract boolean isMatch(Version version, Version latestVersion); @Override String toString(); } | @Test public void getVersionRule() { Assert.assertEquals("abc", versionRule.getVersionRule()); } |
VersionRuleFixedParser implements VersionRuleParser { @Override public VersionRule parse(String strVersionRule) { Version version = new Version(strVersionRule); return new FixedVersionRule(version.getVersion(), version); } @Override VersionRule parse(String strVersionRule); } | @Test public void parseNormal() { versionRule = parser.parse("1"); Assert.assertEquals("1.0.0.0", versionRule.getVersionRule()); }
@Test public void isMatch() { versionRule = parser.parse("1"); Assert.assertTrue(versionRule.isMatch(VersionConst.v1, null)); Assert.assertFalse(versionRule.isMatch(VersionConst.v2, null)); } |
VersionUtils { public static Version getOrCreate(String strVersion) { Objects.requireNonNull(strVersion); return versionCache.computeIfAbsent(strVersion, Version::new); } static Version getOrCreate(String strVersion); } | @Test public void getOrCreate() { Version v = VersionUtils.getOrCreate("1.0.0"); Assert.assertEquals("1.0.0.0", v.getVersion()); Assert.assertSame(v, VersionUtils.getOrCreate("1.0.0")); } |
VersionRuleUtils { public static VersionRule getOrCreate(String strVersionRule) { Objects.requireNonNull(strVersionRule); return versionRuleCache.computeIfAbsent(strVersionRule, VersionRuleUtils::create); } static VersionRule getOrCreate(String strVersionRule); static VersionRule create(String strVersionRule); } | @Test public void fixed() { VersionRule versionRule = VersionRuleUtils.getOrCreate("1"); Assert.assertThat(versionRule, Matchers.instanceOf(FixedVersionRule.class)); Assert.assertSame(versionRule, VersionRuleUtils.getOrCreate("1")); }
@Test public void latest() { VersionRule versionRule = VersionRuleUtils.getOrCreate(DefinitionConst.VERSION_RULE_LATEST); Assert.assertThat(versionRule, Matchers.instanceOf(LatestVersionRule.class)); Assert.assertSame(versionRule, VersionRuleUtils.getOrCreate(DefinitionConst.VERSION_RULE_LATEST)); }
@Test public void range() { VersionRule versionRule = VersionRuleUtils.getOrCreate("1-2"); Assert.assertThat(versionRule, Matchers.instanceOf(RangeVersionRule.class)); Assert.assertSame(versionRule, VersionRuleUtils.getOrCreate("1-2")); }
@Test public void startFrom() { VersionRule versionRule = VersionRuleUtils.getOrCreate("1+"); Assert.assertThat(versionRule, Matchers.instanceOf(StartFromVersionRule.class)); Assert.assertSame(versionRule, VersionRuleUtils.getOrCreate("1+")); }
@Test public void invalid() { expectedException.expect(IllegalStateException.class); expectedException.expectMessage(Matchers.is("Invalid major \"\", version \"\".")); VersionRuleUtils.getOrCreate(""); } |
Version implements Comparable<Version> { @Override public String toString() { return version; } Version(String version); Version(short major, short minor, short patch, short build); short getMajor(); short getMinor(); short getPatch(); short getBuild(); String getVersion(); @Override String toString(); @Override int hashCode(); @Override boolean equals(Object other); @Override int compareTo(Version other); } | @Test public void testToString() { version = new Version(s1, s1, s1, s1); Assert.assertEquals("1.1.1.1", version.toString()); } |
Version implements Comparable<Version> { @Override public int hashCode() { return version.hashCode(); } Version(String version); Version(short major, short minor, short patch, short build); short getMajor(); short getMinor(); short getPatch(); short getBuild(); String getVersion(); @Override String toString(); @Override int hashCode(); @Override boolean equals(Object other); @Override int compareTo(Version other); } | @Test public void testHashCode() { version = new Version(s1, s1, s1, s1); Assert.assertEquals(version.getVersion().hashCode(), version.hashCode()); } |
Version implements Comparable<Version> { @Override public boolean equals(Object other) { if (other == this) { return true; } if (!(other instanceof Version)) { return false; } return numberVersion == ((Version) other).numberVersion; } Version(String version); Version(short major, short minor, short patch, short build); short getMajor(); short getMinor(); short getPatch(); short getBuild(); String getVersion(); @Override String toString(); @Override int hashCode(); @Override boolean equals(Object other); @Override int compareTo(Version other); } | @Test public void testEquals() { version = new Version(s1, s1, s1, s1); Assert.assertTrue(version.equals(version)); Assert.assertTrue(version.equals(new Version(s1, s1, s1, s1))); Assert.assertFalse(version.equals(null)); } |
Version implements Comparable<Version> { @Override public int compareTo(Version other) { return Long.compare(numberVersion, other.numberVersion); } Version(String version); Version(short major, short minor, short patch, short build); short getMajor(); short getMinor(); short getPatch(); short getBuild(); String getVersion(); @Override String toString(); @Override int hashCode(); @Override boolean equals(Object other); @Override int compareTo(Version other); } | @Test public void compareTo() { version = new Version(s1, s1, s1, s1); Assert.assertEquals(0, version.compareTo(version)); Assert.assertEquals(0, version.compareTo(new Version(s1, s1, s1, s1))); Assert.assertEquals(-1, version.compareTo(new Version(s1, s1, s2, s1))); Assert.assertEquals(-1, version.compareTo(new Version(s1, s2, s1, s1))); Assert.assertEquals(-1, version.compareTo(new Version(s2, s1, s1, s1))); Assert.assertEquals(1, version.compareTo(new Version((short) 0, Short.MAX_VALUE, Short.MAX_VALUE, Short.MAX_VALUE))); } |
VersionRuleStartFromParser implements VersionRuleParser { @Override public VersionRule parse(String strVersionRule) { int pos = strVersionRule.indexOf('+'); if (pos <= 0 || pos != strVersionRule.length() - 1) { return null; } Version from = new Version(strVersionRule.substring(0, pos)); return new StartFromVersionRule(from.getVersion() + "+", from); } @Override VersionRule parse(String strVersionRule); } | @Test public void parseInvalid() { Assert.assertNull(parser.parse("")); Assert.assertNull(parser.parse("+")); Assert.assertNull(parser.parse("1+1")); } |
VertxRestAccessLogPatternParser implements AccessLogPatternParser<RoutingContext> { @Override public List<AccessLogItem<RoutingContext>> parsePattern(String rawPattern) { LOGGER.info("parse the pattern of access log: [{}]", rawPattern); List<AccessLogItemLocation> locationList = matchAccessLogItem(rawPattern); locationList = fillInPlainTextLocation(rawPattern, locationList); return convertToItemList(rawPattern, locationList); } VertxRestAccessLogPatternParser(); static int comparePlaceholderString(String s1, String s2); static void sortAccessLogItemMeta(List<VertxRestAccessLogItemMeta> accessLogItemMetaList); @Override List<AccessLogItem<RoutingContext>> parsePattern(String rawPattern); static final Comparator<VertxRestAccessLogItemMeta> accessLogItemMetaComparator; } | @Test public void testParsePatternFullTest() { List<AccessLogItem<RoutingContext>> result = logPatternParser.parsePattern(ROW_PATTERN); assertEquals(29, result.size()); StringBuilder builder = new StringBuilder(); result.get(0).appendServerFormattedItem(accessLogEvent, builder); assertEquals("[", builder.toString()); assertEquals(HttpMethodAccessItem.class, result.get(1).getClass()); builder = new StringBuilder(); result.get(2).appendServerFormattedItem(accessLogEvent, builder); assertEquals("] ", builder.toString()); assertEquals(HttpMethodAccessItem.class, result.get(3).getClass()); builder = new StringBuilder(); result.get(4).appendServerFormattedItem(accessLogEvent, builder); assertEquals(" ", builder.toString()); assertEquals(HttpStatusAccessItem.class, result.get(5).getClass()); assertEquals(DurationSecondAccessItem.class, result.get(6).getClass()); assertEquals(DurationMillisecondAccessItem.class, result.get(7).getClass()); assertEquals(RemoteHostAccessItem.class, result.get(8).getClass()); assertEquals(LocalHostAccessItem.class, result.get(9).getClass()); assertEquals(LocalPortAccessItem.class, result.get(10).getClass()); assertEquals(ResponseSizeAccessItem.class, result.get(11).getClass()); assertEquals("0", ((ResponseSizeAccessItem) result.get(11)).getZeroBytes()); assertEquals(ResponseSizeAccessItem.class, result.get(12).getClass()); assertEquals("-", ((ResponseSizeAccessItem) result.get(12)).getZeroBytes()); assertEquals(FirstLineOfRequestAccessItem.class, result.get(13).getClass()); assertEquals(UrlPathAccessItem.class, result.get(14).getClass()); assertEquals(QueryStringAccessItem.class, result.get(15).getClass()); assertEquals(UrlPathAccessItem.class, result.get(16).getClass()); assertEquals(QueryStringAccessItem.class, result.get(17).getClass()); assertEquals(UrlPathWithQueryAccessItem.class, result.get(18).getClass()); assertEquals(RequestProtocolAccessItem.class, result.get(19).getClass()); assertEquals(ConfigurableDatetimeAccessItem.class, result.get(20).getClass()); assertEquals(ConfigurableDatetimeAccessItem.DEFAULT_DATETIME_PATTERN, ((ConfigurableDatetimeAccessItem) result.get(20)).getPattern()); assertEquals(ConfigurableDatetimeAccessItem.DEFAULT_LOCALE, ((ConfigurableDatetimeAccessItem) result.get(20)).getLocale()); assertEquals(TimeZone.getDefault(), ((ConfigurableDatetimeAccessItem) result.get(20)).getTimezone()); assertEquals("yyyy MM dd HH:mm:ss zzz", ((ConfigurableDatetimeAccessItem) result.get(21)).getPattern()); assertEquals(ConfigurableDatetimeAccessItem.DEFAULT_LOCALE, ((ConfigurableDatetimeAccessItem) result.get(21)).getLocale()); assertEquals(TimeZone.getDefault(), ((ConfigurableDatetimeAccessItem) result.get(21)).getTimezone()); assertEquals("yyyy MM dd HH:mm:ss", ((ConfigurableDatetimeAccessItem) result.get(22)).getPattern()); assertEquals(Locale.forLanguageTag("en-US"), ((ConfigurableDatetimeAccessItem) result.get(22)).getLocale()); assertEquals(TimeZone.getTimeZone("GMT+0"), ((ConfigurableDatetimeAccessItem) result.get(22)).getTimezone()); assertEquals(RequestHeaderAccessItem.class, result.get(23).getClass()); assertEquals("incoming-header", ((RequestHeaderAccessItem) result.get(23)).getVarName()); assertEquals(ResponseHeaderAccessItem.class, result.get(24).getClass()); assertEquals("outgoing-header", ((ResponseHeaderAccessItem) result.get(24)).getVarName()); assertEquals(CookieAccessItem.class, result.get(25).getClass()); assertEquals("cookie", ((CookieAccessItem) result.get(25)).getVarName()); assertEquals(TraceIdAccessItem.class, result.get(26).getClass()); assertEquals(InvocationContextAccessItem.class, result.get(27).getClass()); assertEquals("ctx", ((InvocationContextAccessItem) result.get(27)).getVarName()); assertEquals(TransportAccessItem.class, result.get(28).getClass()); }
@Test public void testParsePattern() { String pattern = " %m cs-uri-stem %{response-header}o "; List<AccessLogItem<RoutingContext>> result = logPatternParser.parsePattern(pattern); assertEquals(7, result.size()); StringBuilder stringBuilder = new StringBuilder(); result.get(0).appendServerFormattedItem(accessLogEvent, stringBuilder); assertEquals(" ", stringBuilder.toString()); assertEquals(HttpMethodAccessItem.class, result.get(1).getClass()); stringBuilder = new StringBuilder(); result.get(2).appendServerFormattedItem(accessLogEvent, stringBuilder); assertEquals(" ", stringBuilder.toString()); assertEquals(UrlPathAccessItem.class, result.get(3).getClass()); stringBuilder = new StringBuilder(); result.get(4).appendServerFormattedItem(accessLogEvent, stringBuilder); assertEquals(" ", stringBuilder.toString()); assertEquals(ResponseHeaderAccessItem.class, result.get(5).getClass()); assertEquals("response-header", ((ResponseHeaderAccessItem) result.get(5)).getVarName()); stringBuilder = new StringBuilder(); result.get(6).appendServerFormattedItem(accessLogEvent, stringBuilder); assertEquals(" ", stringBuilder.toString()); }
@Test public void testParsePatternWithNoBlank() { String pattern = "%mcs-uri-stem%{response-header}o"; List<AccessLogItem<RoutingContext>> result = logPatternParser.parsePattern(pattern); assertEquals(3, result.size()); assertEquals(HttpMethodAccessItem.class, result.get(0).getClass()); assertEquals(UrlPathAccessItem.class, result.get(1).getClass()); assertEquals(ResponseHeaderAccessItem.class, result.get(2).getClass()); assertEquals("response-header", ((ResponseHeaderAccessItem) result.get(2)).getVarName()); }
@Test public void testParsePatternComplex() { String pattern = "%m cs-uri-stem %{response-header}o abc cs-uri-query %s%{request} header}i plain cs-uri"; List<AccessLogItem<RoutingContext>> result = logPatternParser.parsePattern(pattern); assertEquals(12, result.size()); assertEquals(HttpMethodAccessItem.class, result.get(0).getClass()); StringBuilder stringBuilder = new StringBuilder(); result.get(1).appendServerFormattedItem(accessLogEvent, stringBuilder); assertEquals(" ", stringBuilder.toString()); assertEquals(UrlPathAccessItem.class, result.get(2).getClass()); stringBuilder = new StringBuilder(); result.get(3).appendServerFormattedItem(accessLogEvent, stringBuilder); assertEquals(" ", stringBuilder.toString()); assertEquals(ResponseHeaderAccessItem.class, result.get(4).getClass()); assertEquals("response-header", ((ResponseHeaderAccessItem) result.get(4)).getVarName()); stringBuilder = new StringBuilder(); result.get(5).appendServerFormattedItem(accessLogEvent, stringBuilder); assertEquals(" abc ", stringBuilder.toString()); assertEquals(QueryStringAccessItem.class, result.get(6).getClass()); stringBuilder = new StringBuilder(); result.get(7).appendServerFormattedItem(accessLogEvent, stringBuilder); assertEquals(" ", stringBuilder.toString()); assertEquals(HttpStatusAccessItem.class, result.get(8).getClass()); assertEquals(RequestHeaderAccessItem.class, result.get(9).getClass()); assertEquals("request} header", ((RequestHeaderAccessItem) result.get(9)).getVarName()); stringBuilder = new StringBuilder(); result.get(10).appendServerFormattedItem(accessLogEvent, stringBuilder); assertEquals(" plain ", stringBuilder.toString()); assertEquals(UrlPathWithQueryAccessItem.class, result.get(11).getClass()); } |
ServiceRegistryClientImpl implements ServiceRegistryClient { @Override public List<MicroserviceInstance> findServiceInstance(String consumerId, String appId, String serviceName, String versionRule) { MicroserviceInstances instances = findServiceInstances(consumerId, appId, serviceName, versionRule, null); if (instances == null) { return null; } return instances.getInstancesResponse().getInstances(); } ServiceRegistryClientImpl(ServiceRegistryConfig serviceRegistryConfig); @Override void init(); @Override List<Microservice> getAllMicroservices(); @Override String getMicroserviceId(String appId, String microserviceName, String versionRule, String environment); @Override boolean isSchemaExist(String microserviceId, String schemaId); @Override boolean registerSchema(String microserviceId, String schemaId, String schemaContent); @Override String getSchema(String microserviceId, String schemaId); @Override String getAggregatedSchema(String microserviceId, String schemaId); @Override Holder<List<GetSchemaResponse>> getSchemas(String microserviceId); @Override String registerMicroservice(Microservice microservice); @Override Microservice getMicroservice(String microserviceId); @Override Microservice getAggregatedMicroservice(String microserviceId); @Override String registerMicroserviceInstance(MicroserviceInstance instance); @Override List<MicroserviceInstance> getMicroserviceInstance(String consumerId, String providerId); @Override boolean unregisterMicroserviceInstance(String microserviceId, String microserviceInstanceId); @Override HeartbeatResponse heartbeat(String microserviceId, String microserviceInstanceId); void watch(String selfMicroserviceId, AsyncResultCallback<MicroserviceInstanceChangedEvent> callback); void watch(String selfMicroserviceId, AsyncResultCallback<MicroserviceInstanceChangedEvent> callback,
AsyncResultCallback<Void> onOpen, AsyncResultCallback<Void> onClose); @Override List<MicroserviceInstance> findServiceInstance(String consumerId, String appId, String serviceName,
String versionRule); @Override MicroserviceInstances findServiceInstances(String consumerId, String appId, String serviceName,
String versionRule, String revision); @Override boolean updateMicroserviceProperties(String microserviceId, Map<String, String> serviceProperties); @Override boolean updateInstanceProperties(String microserviceId, String microserviceInstanceId,
Map<String, String> instanceProperties); @Override MicroserviceInstance findServiceInstance(String serviceId, String instanceId); @Override ServiceCenterInfo getServiceCenterInfo(); @Override boolean updateMicroserviceInstanceStatus(String microserviceId, String instanceId,
MicroserviceInstanceStatus status); @Subscribe void onMicroserviceHeartbeatTask(MicroserviceInstanceHeartbeatTask event); } | @Test public void testFindServiceInstance() { new MockUp<RestClientUtil>() { @Mock void get(IpPort ipPort, String uri, RequestParam requestParam, Handler<RestResponse> responseHandler) { Assert.assertEquals("global=true", requestParam.getQueryParams()); } }; Assert.assertNull(oClient.findServiceInstance("aaa", "bbb")); }
@Test public void findServiceInstance_consumerId_null() { new MockUp<RestClientUtil>() { @Mock void get(IpPort ipPort, String uri, RequestParam requestParam, Handler<RestResponse> responseHandler) { Assert.assertEquals("appId=appId&global=true&serviceName=serviceName&version=1.0.0%2B", requestParam.getQueryParams()); } }; Assert.assertNull(oClient.findServiceInstance(null, "appId", "serviceName", "1.0.0+")); } |
VertxRestAccessLogPatternParser implements AccessLogPatternParser<RoutingContext> { public static int comparePlaceholderString(String s1, String s2) { int result = s1.compareTo(s2); if (0 == result) { return result; } return result < 0 ? (s2.startsWith(s1) ? -result : result) : (s1.startsWith(s2) ? -result : result); } VertxRestAccessLogPatternParser(); static int comparePlaceholderString(String s1, String s2); static void sortAccessLogItemMeta(List<VertxRestAccessLogItemMeta> accessLogItemMetaList); @Override List<AccessLogItem<RoutingContext>> parsePattern(String rawPattern); static final Comparator<VertxRestAccessLogItemMeta> accessLogItemMetaComparator; } | @Test public void testComparePlaceholderString() { Assert.assertTrue( VertxRestAccessLogPatternParser.comparePlaceholderString("abc", "bbc") < 0 ); Assert.assertTrue( VertxRestAccessLogPatternParser.comparePlaceholderString("abc", "ab") < 0 ); Assert.assertEquals(0, VertxRestAccessLogPatternParser.comparePlaceholderString("abc", "abc")); Assert.assertTrue( VertxRestAccessLogPatternParser.comparePlaceholderString("bbc", "abc") > 0 ); Assert.assertTrue( VertxRestAccessLogPatternParser.comparePlaceholderString("ab", "abc") > 0 ); } |
AccessLogGenerator { public String generateServerLog(ServerAccessLogEvent accessLogEvent) { StringBuilder log = new StringBuilder(128); for (AccessLogItem<RoutingContext> accessLogItem : getAccessLogItems()) { accessLogItem.appendServerFormattedItem(accessLogEvent, log); } return log.toString(); } @SuppressWarnings("unchecked") AccessLogGenerator(String rawPattern); String generateServerLog(ServerAccessLogEvent accessLogEvent); String generateClientLog(InvocationFinishEvent finishEvent); } | @Test public void testServerLog() { RoutingContext context = Mockito.mock(RoutingContext.class); HttpServerRequest request = Mockito.mock(HttpServerRequest.class); long startMillisecond = 1416863450581L; ServerAccessLogEvent serverAccessLogEvent = new ServerAccessLogEvent(); serverAccessLogEvent.setMilliStartTime(startMillisecond).setRoutingContext(context); SimpleDateFormat simpleDateFormat = new SimpleDateFormat(ConfigurableDatetimeAccessItem.DEFAULT_DATETIME_PATTERN, ConfigurableDatetimeAccessItem.DEFAULT_LOCALE); simpleDateFormat.setTimeZone(TimeZone.getDefault()); when(context.request()).thenReturn(request); when(request.method()).thenReturn(HttpMethod.DELETE); String log = LOG_GENERATOR.generateServerLog(serverAccessLogEvent); Assert.assertEquals("DELETE" + " - " + simpleDateFormat.format(startMillisecond), log); } |
AccessLogGenerator { public String generateClientLog(InvocationFinishEvent finishEvent) { StringBuilder log = new StringBuilder(128); for (AccessLogItem<RoutingContext> accessLogItem : getAccessLogItems()) { accessLogItem.appendClientFormattedItem(finishEvent, log); } return log.toString(); } @SuppressWarnings("unchecked") AccessLogGenerator(String rawPattern); String generateServerLog(ServerAccessLogEvent accessLogEvent); String generateClientLog(InvocationFinishEvent finishEvent); } | @Test public void testClientLog() { Invocation invocation = Mockito.mock(Invocation.class); InvocationStageTrace stageTrace = Mockito.mock(InvocationStageTrace.class); OperationMeta operationMeta = Mockito.mock(OperationMeta.class); long startMillisecond = 1416863450581L; when(stageTrace.getStartSend()).thenReturn(0L); when(stageTrace.getStart()).thenReturn(0L); when(stageTrace.getFinish()).thenReturn(0L); when(stageTrace.getStartCurrentTime()).thenReturn(startMillisecond); when(invocation.getOperationMeta()).thenReturn(operationMeta); when(invocation.getInvocationStageTrace()).thenReturn(stageTrace); InvocationFinishEvent finishEvent = new InvocationFinishEvent(invocation, null); SimpleDateFormat simpleDateFormat = new SimpleDateFormat(ConfigurableDatetimeAccessItem.DEFAULT_DATETIME_PATTERN, ConfigurableDatetimeAccessItem.DEFAULT_LOCALE); simpleDateFormat.setTimeZone(TimeZone.getDefault()); when(operationMeta.getHttpMethod()).thenReturn(HttpMethod.DELETE.toString()); String log = LOG_GENERATOR.generateClientLog(finishEvent); Assert.assertEquals("DELETE" + " - " + simpleDateFormat.format(startMillisecond), log); } |
SwaggerToProtoGenerator { public Proto convert() { convertDefinitions(); convertOperations(); for (; ; ) { List<Runnable> oldPending = pending; pending = new ArrayList<>(); for (Runnable runnable : oldPending) { runnable.run(); } if (pending.isEmpty()) { break; } } return createProto(); } SwaggerToProtoGenerator(String protoPackage, Swagger swagger); Proto convert(); static String escapePackageName(String name); static String escapeMessageName(String name); static boolean isValidEnum(String name); } | @Test public void convert() throws IOException { URL url = TestSwaggerToProtoGenerator.class.getClassLoader().getResource("ProtoSchema.proto"); String protoContent = IOUtils.toString(url, "UTF-8"); int idx = protoContent.indexOf("syntax = "); protoContent = protoContent.substring(idx); SpringmvcSwaggerGenerator swaggerGenerator = new SpringmvcSwaggerGenerator(ProtoSchema.class); Swagger swagger = swaggerGenerator.generate(); SwaggerToProtoGenerator generator = new SwaggerToProtoGenerator("a.b", swagger); Proto proto = generator.convert(); Assert.assertEquals(protoContent.replaceAll("\r\n", "\n"), new ProtoToStringGenerator(proto).protoToString().replaceAll("\r\n", "\n")); } |
ProtoToStringGenerator { public String protoToString() { StringBuilder sb = new StringBuilder(); appendLine(sb, "syntax = \"%s\";", proto.getSyntax()); for (Import importValue : proto.getImports()) { appendLine(sb, "import \"%s\";", importValue.getValue()); } appendLine(sb, "package %s;\n", proto.getPackage().getValue()); for (Message message : proto.getMessages()) { messageToString(message, sb); } for (Enum enumValue : proto.getEnums()) { enumToString(enumValue, sb); } for (Service service : proto.getServices()) { serviceToString(service, sb); } return sb.toString(); } ProtoToStringGenerator(Proto proto); String protoToString(); } | @Test public void protoToString() { ProtoParser protoParser = new ProtoParser(); Proto proto = protoParser.parseFromContent(content); String newContent = new ProtoToStringGenerator(proto).protoToString(); Assert.assertEquals(content, newContent); } |
ResponseRootDeserializer { public static boolean needConvert(Object obj, JavaType invocationTimeType) { if (obj == null || ClassUtils.isPrimitiveOrWrapper(obj.getClass()) || invocationTimeType.isPrimitive() || ProtoConst.OBJECT_TYPE.equals(invocationTimeType)) { return false; } if (obj.getClass() == invocationTimeType.getRawClass()) { return false; } if (invocationTimeType.getRawClass().isAssignableFrom(obj.getClass())) { if (invocationTimeType.getContentType() == null) { return false; } } return true; } ResponseRootDeserializer(RootDeserializer<T> rootDeserializer, boolean empty); @SuppressWarnings("unchecked") T deserialize(byte[] bytes, JavaType invocationTimeType); static boolean needConvert(Object obj, JavaType invocationTimeType); } | @Test public void testNeedConvert() { Assert.assertEquals(SimpleType.constructUnsafe(Object.class), ProtoConst.OBJECT_TYPE); Assert.assertEquals(false, ResponseRootDeserializer.needConvert(1, TypeFactory.defaultInstance().constructType(int.class))); Assert.assertEquals(false, ResponseRootDeserializer.needConvert(1, TypeFactory.defaultInstance().constructType(Integer.class))); Assert.assertEquals(false, ResponseRootDeserializer .needConvert(Integer.valueOf(1), TypeFactory.defaultInstance().constructType(int.class))); Assert.assertEquals(false, ResponseRootDeserializer .needConvert(Integer.valueOf(1), TypeFactory.defaultInstance().constructType(Integer.class))); Assert.assertEquals(true, ResponseRootDeserializer .needConvert(new HashMap<>(), TypeFactory.defaultInstance().constructType(Model.class))); Assert.assertEquals(false, ResponseRootDeserializer .needConvert(new Model(), TypeFactory.defaultInstance().constructType(Model.class))); Assert.assertEquals(false, ResponseRootDeserializer .needConvert(new Model(), TypeFactory.defaultInstance().constructType(Object.class))); List<Model> modelList = new ArrayList<>(); List<Map> modemaplList = new ArrayList<>(); Assert.assertEquals(true, ResponseRootDeserializer .needConvert(modemaplList, TypeFactory.defaultInstance().constructType(new TypeReference<List<Model>>() { }))); Assert.assertEquals(true, ResponseRootDeserializer .needConvert(modelList, TypeFactory.defaultInstance().constructType(new TypeReference<List<Model>>() { }))); } |
RestCodec { public static void argsToRest(Map<String, Object> args, RestOperationMeta restOperation, RestClientRequest clientRequest) throws Exception { int paramSize = restOperation.getParamList().size(); if (paramSize == 0) { return; } for (int idx = 0; idx < paramSize; idx++) { RestParam param = restOperation.getParamList().get(idx); param.getParamProcessor().setValue(clientRequest, args.get(param.getParamName())); } } private RestCodec(); static void argsToRest(Map<String, Object> args, RestOperationMeta restOperation,
RestClientRequest clientRequest); static Map<String, Object> restToArgs(HttpServletRequest request,
RestOperationMeta restOperation); } | @Test public void testArgsToRest() { try { Map<String, Object> args = new HashMap<>(); args.put("header", "abc"); RestCodec.argsToRest(args, restOperation, clientRequest); Assert.assertEquals("abc", header.get("header")); } catch (Exception e) { e.printStackTrace(); Assert.assertTrue(false); } } |
RestCodec { public static Map<String, Object> restToArgs(HttpServletRequest request, RestOperationMeta restOperation) throws InvocationException { List<RestParam> paramList = restOperation.getParamList(); Map<String, Object> paramValues = new HashMap<>(); for (int idx = 0; idx < paramList.size(); idx++) { RestParam param = paramList.get(idx); try { paramValues.put(param.getParamName(), param.getParamProcessor().getValue(request)); } catch (Exception e) { String message = String .format("Parameter is not valid for operation [%s]. Parameter is [%s]. Processor is [%s].", restOperation.getOperationMeta().getMicroserviceQualifiedName(), param.getParamName(), param.getParamProcessor().getProcessorType()); if (DynamicPropertyFactory.getInstance().getBooleanProperty( RestConst.PRINT_CODEC_ERROR_MESSGAGE, false).get()) { LOG.error(message, e); } else { LOG.error("{} Add {}=true to print the details.", message, RestConst.PRINT_CODEC_ERROR_MESSGAGE); } throw new InvocationException(Status.BAD_REQUEST, message); } } return paramValues; } private RestCodec(); static void argsToRest(Map<String, Object> args, RestOperationMeta restOperation,
RestClientRequest clientRequest); static Map<String, Object> restToArgs(HttpServletRequest request,
RestOperationMeta restOperation); } | @Test public void testRestToArgs(@Mocked HttpServletRequest request, @Mocked RestOperationMeta restOperation, @Mocked RestParam restParam, @Mocked ParamValueProcessor processer) throws Exception { List<RestParam> params = new ArrayList<>(); params.add(restParam); String s = "my"; new Expectations() { { restOperation.getParamList(); result = params; restParam.getParamProcessor(); result = processer; processer.getValue(request); result = s; restParam.getParamName(); result = "test"; } }; Map<String, Object> xx = RestCodec.restToArgs(request, restOperation); Assert.assertEquals(xx.get("test"), s); }
@Test public void testRestToArgsExcetpion(@Mocked HttpServletRequest request, @Mocked RestOperationMeta restOperation, @Mocked RestParam restParam, @Mocked ParamValueProcessor processer) throws Exception { List<RestParam> params = new ArrayList<>(); params.add(restParam); new Expectations() { { restOperation.getParamList(); result = params; restParam.getParamProcessor(); result = processer; processer.getValue(request); result = new Exception("bad request parame"); } }; boolean success = false; try { RestCodec.restToArgs(request, restOperation); success = true; } catch (InvocationException e) { Assert.assertEquals(400, e.getStatusCode()); Assert.assertTrue(((CommonExceptionData) e.getErrorData()).getMessage().contains("Parameter is not valid")); } Assert.assertEquals(success, false); }
@Test public void testRestToArgsInstanceExcetpion(@Mocked HttpServletRequest request, @Mocked RestOperationMeta restOperation, @Mocked RestParam restParam, @Mocked ParamValueProcessor processer) throws Exception { List<RestParam> params = new ArrayList<>(); params.add(restParam); InvocationException exception = new InvocationException(Status.BAD_REQUEST, "Parameter is not valid."); new Expectations() { { restOperation.getParamList(); result = params; restParam.getParamProcessor(); result = processer; processer.getValue(request); result = exception; } }; boolean success = false; try { RestCodec.restToArgs(request, restOperation); success = true; } catch (InvocationException e) { Assert.assertEquals(e.getStatusCode(), Status.BAD_REQUEST.getStatusCode()); } Assert.assertEquals(success, false); } |
ProduceJsonProcessor implements ProduceProcessor { @Override public void setSerializationView(Class<?> serializationView) { if (serializationView == null) { return; } this.serializationView = serializationView; } @Override String getSerializationView(); @Override void setSerializationView(Class<?> serializationView); @Override String getName(); @Override void doEncodeResponse(OutputStream output, Object result); @Override Object doDecodeResponse(InputStream input, JavaType type); @Override int getOrder(); } | @Test public void testSetSerializationView() { Assert.assertEquals(DEFAULT_SERIAL_CLASS, pp.getSerializationView()); pp.setSerializationView(null); Assert.assertEquals(DEFAULT_SERIAL_CLASS, pp.getSerializationView()); pp.setSerializationView(Object.class); Assert.assertEquals(Object.class.getCanonicalName(), pp.getSerializationView()); } |
PathProcessorCreator implements ParamValueProcessorCreator { @Override public ParamValueProcessor create(Parameter parameter, Type genericParamType) { JavaType targetType = genericParamType == null ? null : TypeFactory.defaultInstance().constructType(genericParamType); return new PathProcessor(parameter.getName(), targetType, ((PathParameter) parameter).getDefaultValue(), true); } PathProcessorCreator(); @Override ParamValueProcessor create(Parameter parameter, Type genericParamType); static final String PARAMTYPE; } | @Test public void testCreate() { ParamValueProcessorCreator creator = ParamValueProcessorCreatorManager.INSTANCE.findValue(PathProcessorCreator.PARAMTYPE); Parameter parameter = new PathParameter(); parameter.setName("path"); ParamValueProcessor processor = creator.create(parameter, String.class); Assert.assertEquals(PathProcessor.class, processor.getClass()); } |
FormProcessorCreator implements ParamValueProcessorCreator { @Override public ParamValueProcessor create(Parameter parameter, Type genericParamType) { JavaType targetType = genericParamType == null ? null : TypeFactory.defaultInstance().constructType(genericParamType); if (isPart(parameter)) { return new PartProcessor((FormParameter) parameter, genericParamType); } return new FormProcessor((FormParameter) parameter, targetType); } FormProcessorCreator(); @Override ParamValueProcessor create(Parameter parameter, Type genericParamType); static final String PARAMTYPE; } | @Test public void testCreate() { ParamValueProcessorCreator creator = ParamValueProcessorCreatorManager.INSTANCE.findValue(FormProcessorCreator.PARAMTYPE); FormParameter p = new FormParameter(); p.setName("p1"); ParamValueProcessor processor = creator.create(p, String.class); Assert.assertEquals(FormProcessor.class, processor.getClass()); } |
QueryProcessorCreator implements ParamValueProcessorCreator { @Override public ParamValueProcessor create(Parameter parameter, Type genericParamType) { JavaType targetType = genericParamType == null ? null : TypeFactory.defaultInstance().constructType(genericParamType); return new QueryProcessor((QueryParameter) parameter, targetType); } QueryProcessorCreator(); @Override ParamValueProcessor create(Parameter parameter, Type genericParamType); static final String PARAMTYPE; } | @Test public void testCreate() { ParamValueProcessorCreator creator = ParamValueProcessorCreatorManager.INSTANCE.findValue(QueryProcessorCreator.PARAMTYPE); Parameter parameter = new QueryParameter(); parameter.setName("query"); ParamValueProcessor processor = creator.create(parameter, String.class); Assert.assertEquals(QueryProcessor.class, processor.getClass()); String result = (String) processor.convertValue("Hello", TypeFactory.defaultInstance().constructType(String.class)); Assert.assertEquals("Hello", result); result = (String) processor.convertValue("", TypeFactory.defaultInstance().constructType(String.class)); Assert.assertEquals("", result); result = (String) processor.convertValue(null, TypeFactory.defaultInstance().constructType(String.class)); Assert.assertEquals(null, result); }
@SuppressWarnings("UnusedAssignment") @Test public void testCreateNullAsEmpty() throws Exception { HttpServletRequest request = Mockito.mock(HttpServletRequest.class); ArchaiusUtils.setProperty("servicecomb.rest.parameter.query.emptyAsNull", "true"); ParamValueProcessorCreator creator = ParamValueProcessorCreatorManager.INSTANCE.findValue(QueryProcessorCreator.PARAMTYPE); Parameter parameter = new QueryParameter(); parameter.setName("query"); ParamValueProcessor processor = creator.create(parameter, String.class); Assert.assertEquals(QueryProcessor.class, processor.getClass()); Mockito.when(request.getParameter("query")).thenReturn("Hello"); String result = (String) processor.getValue(request); Assert.assertEquals("Hello", result); Mockito.when(request.getParameter("query")).thenReturn(""); result = (String) processor.getValue(request); Assert.assertEquals(null, result); Mockito.when(request.getParameter("query")).thenReturn(null); result = (String) processor.convertValue(null, TypeFactory.defaultInstance().constructType(String.class)); result = (String) processor.getValue(request); Assert.assertEquals(null, result); } |
RestClientRequestImpl implements RestClientRequest { protected Buffer fileBoundaryInfo(String boundary, String name, Part part) { Buffer buffer = Buffer.buffer(); buffer.appendString("\r\n"); buffer.appendString("--" + boundary + "\r\n"); buffer.appendString("Content-Disposition: form-data; name=\"") .appendString(name) .appendString("\"; filename=\"") .appendString(part.getSubmittedFileName() != null ? part.getSubmittedFileName() : "null") .appendString("\"\r\n"); buffer.appendString("Content-Type: ").appendString(part.getContentType()).appendString("\r\n"); buffer.appendString("Content-Transfer-Encoding: binary\r\n"); buffer.appendString("\r\n"); return buffer; } RestClientRequestImpl(HttpClientRequest request, Context context, AsyncResponse asyncResp); RestClientRequestImpl(HttpClientRequest request, Context context, AsyncResponse asyncResp,
Handler<Throwable> throwableHandler); @Override void write(Buffer bodyBuffer); @Override Buffer getBodyBuffer(); @Override @SuppressWarnings("unchecked") void attach(String name, Object partOrList); @Override void end(); Context getContext(); HttpClientRequest getRequest(); Map<String, String> getCookieMap(); Map<String, Object> getFormMap(); @Override void addCookie(String name, String value); @Override void addForm(String name, Object value); @Override void putHeader(String name, String value); @Override MultiMap getHeaders(); } | @Test public void fileBoundaryInfo_nullSubmittedFileName(@Mocked Part part) { new Expectations() { { part.getSubmittedFileName(); result = null; part.getContentType(); result = "abc"; } }; RestClientRequestImpl restClientRequest = new RestClientRequestImpl(request, null, null); Buffer buffer = restClientRequest.fileBoundaryInfo("boundary", "name", part); Assert.assertEquals("\r\n" + "--boundary\r\n" + "Content-Disposition: form-data; name=\"name\"; filename=\"null\"\r\n" + "Content-Type: abc\r\n" + "Content-Transfer-Encoding: binary\r\n" + "\r\n", buffer.toString()); }
@Test public void fileBoundaryInfo_validSubmittedFileName(@Mocked Part part) { new Expectations() { { part.getSubmittedFileName(); result = "a.txt"; part.getContentType(); result = MediaType.TEXT_PLAIN; } }; RestClientRequestImpl restClientRequest = new RestClientRequestImpl(request, null, null); Buffer buffer = restClientRequest.fileBoundaryInfo("boundary", "name", part); Assert.assertEquals("\r\n" + "--boundary\r\n" + "Content-Disposition: form-data; name=\"name\"; filename=\"a.txt\"\r\n" + "Content-Type: text/plain\r\n" + "Content-Transfer-Encoding: binary\r\n" + "\r\n", buffer.toString()); } |
RestClientRequestImpl implements RestClientRequest { @Override @SuppressWarnings("unchecked") public void attach(String name, Object partOrList) { if (null == partOrList) { LOGGER.debug("null file is ignored, file name = [{}]", name); return; } if (partOrList.getClass().isArray()) { for (Object part : (Object[]) partOrList) { uploads.put(name, PartUtils.getSinglePart(name, part)); } } if (List.class.isAssignableFrom(partOrList.getClass())) { for (Object part : (List<Object>) partOrList) { uploads.put(name, PartUtils.getSinglePart(name, part)); } return; } uploads.put(name, PartUtils.getSinglePart(name, partOrList)); } RestClientRequestImpl(HttpClientRequest request, Context context, AsyncResponse asyncResp); RestClientRequestImpl(HttpClientRequest request, Context context, AsyncResponse asyncResp,
Handler<Throwable> throwableHandler); @Override void write(Buffer bodyBuffer); @Override Buffer getBodyBuffer(); @Override @SuppressWarnings("unchecked") void attach(String name, Object partOrList); @Override void end(); Context getContext(); HttpClientRequest getRequest(); Map<String, String> getCookieMap(); Map<String, Object> getFormMap(); @Override void addCookie(String name, String value); @Override void addForm(String name, Object value); @Override void putHeader(String name, String value); @Override MultiMap getHeaders(); } | @Test public void testAttach() { RestClientRequestImpl restClientRequest = new RestClientRequestImpl(request, null, null); Part part = Mockito.mock(Part.class); String fileName = "fileName"; restClientRequest.attach(fileName, part); Multimap<String, Part> uploads = Deencapsulation.getField(restClientRequest, "uploads"); Assert.assertEquals(1, uploads.size()); Assert.assertThat(uploads.asMap(), Matchers.hasEntry(fileName, Arrays.asList(part))); }
@Test public void testAttachOnPartIsNull() { RestClientRequestImpl restClientRequest = new RestClientRequestImpl(request, null, null); restClientRequest.attach("fileName", null); Multimap<String, Part> uploads = Deencapsulation.getField(restClientRequest, "uploads"); Assert.assertTrue(uploads.isEmpty()); } |
ServiceRegistryClientImpl implements ServiceRegistryClient { @Override public MicroserviceInstances findServiceInstances(String consumerId, String appId, String serviceName, String versionRule, String revision) { MicroserviceInstances microserviceInstances = new MicroserviceInstances(); IpPort ipPort = ipPortManager.getAvailableAddress(); CountDownLatch countDownLatch = new CountDownLatch(1); RequestParam requestParam = new RequestParam().addQueryParam("appId", appId) .addQueryParam("serviceName", serviceName) .addQueryParam("global", "true") .addQueryParam("version", versionRule); if (RegistryUtils.getMicroservice().getEnvironment() != null) { requestParam.addQueryParam("env", RegistryUtils.getMicroservice().getEnvironment()); } if (consumerId != null) { requestParam.addHeader("X-ConsumerId", consumerId); } if (revision != null) { requestParam.addQueryParam("rev", revision); } restClientUtil.get(ipPort, Const.REGISTRY_API.MICROSERVICE_INSTANCES, requestParam, syncHandlerForInstances(countDownLatch, microserviceInstances)); try { countDownLatch.await(); if (!microserviceInstances.isNeedRefresh()) { return microserviceInstances; } if (microserviceInstances.getInstancesResponse() == null) { return null; } List<MicroserviceInstance> list = microserviceInstances.getInstancesResponse().getInstances(); if (list == null) { microserviceInstances.getInstancesResponse().setInstances(new ArrayList<>()); } return microserviceInstances; } catch (Exception e) { LOGGER.error("find microservice instance {}/{}/{} failed", appId, serviceName, versionRule, e); } return null; } ServiceRegistryClientImpl(ServiceRegistryConfig serviceRegistryConfig); @Override void init(); @Override List<Microservice> getAllMicroservices(); @Override String getMicroserviceId(String appId, String microserviceName, String versionRule, String environment); @Override boolean isSchemaExist(String microserviceId, String schemaId); @Override boolean registerSchema(String microserviceId, String schemaId, String schemaContent); @Override String getSchema(String microserviceId, String schemaId); @Override String getAggregatedSchema(String microserviceId, String schemaId); @Override Holder<List<GetSchemaResponse>> getSchemas(String microserviceId); @Override String registerMicroservice(Microservice microservice); @Override Microservice getMicroservice(String microserviceId); @Override Microservice getAggregatedMicroservice(String microserviceId); @Override String registerMicroserviceInstance(MicroserviceInstance instance); @Override List<MicroserviceInstance> getMicroserviceInstance(String consumerId, String providerId); @Override boolean unregisterMicroserviceInstance(String microserviceId, String microserviceInstanceId); @Override HeartbeatResponse heartbeat(String microserviceId, String microserviceInstanceId); void watch(String selfMicroserviceId, AsyncResultCallback<MicroserviceInstanceChangedEvent> callback); void watch(String selfMicroserviceId, AsyncResultCallback<MicroserviceInstanceChangedEvent> callback,
AsyncResultCallback<Void> onOpen, AsyncResultCallback<Void> onClose); @Override List<MicroserviceInstance> findServiceInstance(String consumerId, String appId, String serviceName,
String versionRule); @Override MicroserviceInstances findServiceInstances(String consumerId, String appId, String serviceName,
String versionRule, String revision); @Override boolean updateMicroserviceProperties(String microserviceId, Map<String, String> serviceProperties); @Override boolean updateInstanceProperties(String microserviceId, String microserviceInstanceId,
Map<String, String> instanceProperties); @Override MicroserviceInstance findServiceInstance(String serviceId, String instanceId); @Override ServiceCenterInfo getServiceCenterInfo(); @Override boolean updateMicroserviceInstanceStatus(String microserviceId, String instanceId,
MicroserviceInstanceStatus status); @Subscribe void onMicroserviceHeartbeatTask(MicroserviceInstanceHeartbeatTask event); } | @Test public void findServiceInstances_microserviceNotExist() { HttpClientResponse response = new MockUp<HttpClientResponse>() { @Mock int statusCode() { return 400; } @Mock HttpClientResponse bodyHandler(Handler<Buffer> bodyHandler) { Buffer bodyBuffer = Buffer.buffer("{\"errorCode\":\"400012\"}"); bodyHandler.handle(bodyBuffer); return null; } }.getMockInstance(); RestResponse restResponse = new RestResponse(null, response); new MockUp<RestClientUtil>() { @Mock void httpDo(RequestContext requestContext, Handler<RestResponse> responseHandler) { Assert.assertEquals("appId=appId&global=true&serviceName=serviceName&version=0.0.0.0%2B", requestContext.getParams().getQueryParams()); restResponse.setRequestContext(requestContext); responseHandler.handle(restResponse); } }; MicroserviceInstances microserviceInstances = oClient .findServiceInstances("consumerId", "appId", "serviceName", DefinitionConst.VERSION_RULE_ALL, null); Assert.assertTrue(microserviceInstances.isMicroserviceNotExist()); Assert.assertFalse(microserviceInstances.isNeedRefresh()); } |
RestClientRequestImpl implements RestClientRequest { protected void doEndWithUpload() { request.setChunked(true); String boundary = "boundary" + UUID.randomUUID().toString(); putHeader(CONTENT_TYPE, MULTIPART_FORM_DATA + "; charset=UTF-8; boundary=" + boundary); genBodyForm(boundary); attachFiles(boundary); } RestClientRequestImpl(HttpClientRequest request, Context context, AsyncResponse asyncResp); RestClientRequestImpl(HttpClientRequest request, Context context, AsyncResponse asyncResp,
Handler<Throwable> throwableHandler); @Override void write(Buffer bodyBuffer); @Override Buffer getBodyBuffer(); @Override @SuppressWarnings("unchecked") void attach(String name, Object partOrList); @Override void end(); Context getContext(); HttpClientRequest getRequest(); Map<String, String> getCookieMap(); Map<String, Object> getFormMap(); @Override void addCookie(String name, String value); @Override void addForm(String name, Object value); @Override void putHeader(String name, String value); @Override MultiMap getHeaders(); } | @Test public void doEndWithUpload() { Map<String, String> headers = new HashMap<>(); new MockUp<HttpClientRequest>(request) { @Mock HttpClientRequest putHeader(String name, String value) { headers.put(name, value); return request; } }; UUID uuid = new UUID(0, 0); new Expectations(UUID.class) { { UUID.randomUUID(); result = uuid; } }; RestClientRequestImpl restClientRequest = new RestClientRequestImpl(request, null, null); restClientRequest.doEndWithUpload(); Assert.assertEquals("multipart/form-data; charset=UTF-8; boundary=boundary00000000-0000-0000-0000-000000000000", headers.get(HttpHeaders.CONTENT_TYPE.toString())); } |
BodyProcessorCreator implements ParamValueProcessorCreator { @Override public ParamValueProcessor create(Parameter parameter, Type genericParamType) { Model model = ((BodyParameter) parameter).getSchema(); JavaType swaggerType = null; if (model instanceof ModelImpl) { swaggerType = ConverterMgr.findJavaType(((ModelImpl) model).getType(), ((ModelImpl) model).getFormat()); } boolean isString = swaggerType != null && swaggerType.getRawClass().equals(String.class); JavaType targetType = genericParamType == null ? null : TypeFactory.defaultInstance().constructType(genericParamType); boolean rawJson = SwaggerUtils.isRawJsonType(parameter); if (rawJson) { return new RawJsonBodyProcessor(targetType, (String) parameter.getVendorExtensions() .get(SwaggerConst.EXT_JSON_VIEW), isString, parameter.getRequired()); } return new BodyProcessor(targetType, (String) parameter.getVendorExtensions() .get(SwaggerConst.EXT_JSON_VIEW), isString, parameter.getRequired()); } BodyProcessorCreator(); @Override ParamValueProcessor create(Parameter parameter, Type genericParamType); static final String PARAMTYPE; } | @Test public void testCreateNormal() { ParamValueProcessorCreator creator = ParamValueProcessorCreatorManager.INSTANCE.findValue(BodyProcessorCreator.PARAMTYPE); BodyParameter param = new BodyParameter(); ParamValueProcessor processor = creator.create(param, String.class); Assert.assertEquals(BodyProcessor.class, processor.getClass()); }
@Test public void testCreateRawJson() { ParamValueProcessorCreator creator = ParamValueProcessorCreatorManager.INSTANCE.findValue(BodyProcessorCreator.PARAMTYPE); BodyParameter param = new BodyParameter(); param.setVendorExtension(SwaggerConst.EXT_RAW_JSON_TYPE, true); ParamValueProcessor processor = creator.create(param, String.class); Assert.assertEquals(RawJsonBodyProcessor.class, processor.getClass()); } |
HeaderProcessorCreator implements ParamValueProcessorCreator { @Override public ParamValueProcessor create(Parameter parameter, Type genericParamType) { JavaType targetType = genericParamType == null ? null : TypeFactory.defaultInstance().constructType(genericParamType); return new HeaderProcessor((HeaderParameter) parameter, targetType); } HeaderProcessorCreator(); @Override ParamValueProcessor create(Parameter parameter, Type genericParamType); static final String PARAMTYPE; } | @Test public void testCreate() { ParamValueProcessorCreator creator = ParamValueProcessorCreatorManager.INSTANCE.findValue(HeaderProcessorCreator.PARAMTYPE); HeaderParameter hp = new HeaderParameter(); hp.setName("h1"); ParamValueProcessor processor = creator.create(hp, String.class); Assert.assertEquals(HeaderProcessor.class, processor.getClass()); } |
CookieProcessorCreator implements ParamValueProcessorCreator { @Override public ParamValueProcessor create(Parameter parameter, Type genericParamType) { JavaType targetType = genericParamType == null ? null : TypeFactory.defaultInstance().constructType(genericParamType); return new CookieProcessor(parameter.getName(), targetType, ((CookieParameter) parameter).getDefaultValue(), parameter.getRequired()); } CookieProcessorCreator(); @Override ParamValueProcessor create(Parameter parameter, Type genericParamType); static final String PARAMTYPE; } | @Test public void testCreate() { ParamValueProcessorCreator creator = ParamValueProcessorCreatorManager.INSTANCE.findValue(CookieProcessorCreator.PARAMTYPE); CookieParameter p = new CookieParameter(); p.setName("p1"); ParamValueProcessor processor = creator.create(p, String.class); Assert.assertEquals(CookieProcessor.class, processor.getClass()); } |
RestProducerInvocationCreator implements InvocationCreator { @Override public Invocation create() { initRestOperation(); Invocation invocation = InvocationFactory.forProvider(endpoint, restOperationMeta.getOperationMeta(), null); initInvocationContext(invocation); initProduceProcessor(); initTransportContext(invocation); invocation.addLocalContext(RestConst.REST_REQUEST, requestEx); return invocation; } RestProducerInvocationCreator(@Nonnull MicroserviceMeta microserviceMeta, @Nonnull Endpoint endpoint,
@Nonnull HttpServletRequestEx requestEx, @Nonnull HttpServletResponseEx responseEx); @Override Invocation create(); } | @Test public void should_failed_when_not_defined_any_schema() { mockGetServicePathManager(null); InvocationException throwable = (InvocationException) catchThrowable(() -> creator.create()); CommonExceptionData data = (CommonExceptionData) throwable.getErrorData(); assertThat(throwable.getStatusCode()).isEqualTo(NOT_FOUND.getStatusCode()); assertThat(Json.encode(data)).isEqualTo("{\"code\":\"SCB.00000002\",\"message\":\"Not Found\"}"); }
@Test public void should_failed_when_accept_is_not_support() { mockGetServicePathManager(); new Expectations() { { requestEx.getHeader(HttpHeaders.ACCEPT); result = "test-type"; restOperationMeta.ensureFindProduceProcessor(requestEx); result = null; } }; InvocationException throwable = (InvocationException) catchThrowable(() -> creator.create()); CommonExceptionData data = (CommonExceptionData) throwable.getErrorData(); assertThat(throwable.getStatusCode()).isEqualTo(NOT_ACCEPTABLE.getStatusCode()); assertThat(Json.encode(data)) .isEqualTo("{\"code\":\"SCB.00000000\",\"message\":\"Accept test-type is not supported\"}"); }
@Test public void should_save_requestEx_in_invocation_context() { mockGetServicePathManager(); Invocation invocation = creator.create(); Object request = invocation.getLocalContext(RestConst.REST_REQUEST); assertThat(request).isSameAs(requestEx); }
@Test public void should_save_path_var_map_in_requestEx() { mockGetServicePathManager(); creator.create(); new Verifications() { { requestEx.setAttribute(RestConst.PATH_PARAMETERS, any); times = 1; } }; }
@Test public void should_merge_invocation_context_from_request() { mockGetServicePathManager(); new Expectations() { { requestEx.getHeader(Const.CSE_CONTEXT); result = "{\"k\":\"v\"}"; } }; Invocation invocation = creator.create(); assertThat(invocation.getContext("k")).isEqualTo("v"); } |
ServiceRegistryClientImpl implements ServiceRegistryClient { @Override public ServiceCenterInfo getServiceCenterInfo() { Holder<ServiceCenterInfo> holder = new Holder<>(); IpPort ipPort = ipPortManager.getAvailableAddress(); CountDownLatch countDownLatch = new CountDownLatch(1); restClientUtil.get(ipPort, Const.REGISTRY_API.SERVICECENTER_VERSION, new RequestParam(), syncHandler(countDownLatch, ServiceCenterInfo.class, holder)); try { countDownLatch.await(); if (holder.value != null) { return holder.value; } } catch (Exception e) { LOGGER.error("query servicecenter version info failed.", e); } return null; } ServiceRegistryClientImpl(ServiceRegistryConfig serviceRegistryConfig); @Override void init(); @Override List<Microservice> getAllMicroservices(); @Override String getMicroserviceId(String appId, String microserviceName, String versionRule, String environment); @Override boolean isSchemaExist(String microserviceId, String schemaId); @Override boolean registerSchema(String microserviceId, String schemaId, String schemaContent); @Override String getSchema(String microserviceId, String schemaId); @Override String getAggregatedSchema(String microserviceId, String schemaId); @Override Holder<List<GetSchemaResponse>> getSchemas(String microserviceId); @Override String registerMicroservice(Microservice microservice); @Override Microservice getMicroservice(String microserviceId); @Override Microservice getAggregatedMicroservice(String microserviceId); @Override String registerMicroserviceInstance(MicroserviceInstance instance); @Override List<MicroserviceInstance> getMicroserviceInstance(String consumerId, String providerId); @Override boolean unregisterMicroserviceInstance(String microserviceId, String microserviceInstanceId); @Override HeartbeatResponse heartbeat(String microserviceId, String microserviceInstanceId); void watch(String selfMicroserviceId, AsyncResultCallback<MicroserviceInstanceChangedEvent> callback); void watch(String selfMicroserviceId, AsyncResultCallback<MicroserviceInstanceChangedEvent> callback,
AsyncResultCallback<Void> onOpen, AsyncResultCallback<Void> onClose); @Override List<MicroserviceInstance> findServiceInstance(String consumerId, String appId, String serviceName,
String versionRule); @Override MicroserviceInstances findServiceInstances(String consumerId, String appId, String serviceName,
String versionRule, String revision); @Override boolean updateMicroserviceProperties(String microserviceId, Map<String, String> serviceProperties); @Override boolean updateInstanceProperties(String microserviceId, String microserviceInstanceId,
Map<String, String> instanceProperties); @Override MicroserviceInstance findServiceInstance(String serviceId, String instanceId); @Override ServiceCenterInfo getServiceCenterInfo(); @Override boolean updateMicroserviceInstanceStatus(String microserviceId, String instanceId,
MicroserviceInstanceStatus status); @Subscribe void onMicroserviceHeartbeatTask(MicroserviceInstanceHeartbeatTask event); } | @Test public void testGetServiceCenterInfoSuccess() { ServiceCenterInfo serviceCenterInfo = new ServiceCenterInfo(); serviceCenterInfo.setVersion("x.x.x"); serviceCenterInfo.setBuildTag("xxx"); serviceCenterInfo.setRunMode("dev"); serviceCenterInfo.setApiVersion("x.x.x"); serviceCenterInfo.setConfig(new ServiceCenterConfig()); new MockUp<RestClientUtil>() { @Mock void httpDo(RequestContext requestContext, Handler<RestResponse> responseHandler) { Holder<ServiceCenterInfo> holder = Deencapsulation.getField(responseHandler, "arg$4"); holder.value = serviceCenterInfo; } }; ServiceCenterInfo info = oClient.getServiceCenterInfo(); Assert.assertEquals("x.x.x", info.getVersion()); Assert.assertEquals("xxx", info.getBuildTag()); Assert.assertEquals("dev", info.getRunMode()); Assert.assertNotNull(info.getConfig()); }
@Test public void testGetServiceCenterInfoException() { InterruptedException e = new InterruptedException(); new MockUp<CountDownLatch>() { @Mock public void await() throws InterruptedException { throw e; } }; new RegisterSchemaTester() { void doRun(java.util.List<LoggingEvent> events) { oClient.getServiceCenterInfo(); Assert.assertEquals( "query servicecenter version info failed.", events.get(0).getMessage()); Assert.assertEquals(e, events.get(0).getThrowableInformation().getThrowable()); } }.run(); } |
HttpServerFilterBeforeSendResponseExecutor { public CompletableFuture<Void> run() { doRun(); return future; } HttpServerFilterBeforeSendResponseExecutor(List<HttpServerFilter> httpServerFilters, Invocation invocation,
HttpServletResponseEx responseEx); CompletableFuture<Void> run(); } | @Test public void runSucc() throws InterruptedException, ExecutionException { CompletableFuture<Void> result = executor.run(); Assert.assertNull(result.get()); }
@Test public void runFail() throws InterruptedException, ExecutionException { httpServerFilters.add(new HttpServerFilterBaseForTest() { @Override public CompletableFuture<Void> beforeSendResponseAsync(Invocation invocation, HttpServletResponseEx responseEx) { throw new RuntimeExceptionWithoutStackTrace(); } }); CompletableFuture<Void> result = executor.run(); expectedException.expect(ExecutionException.class); expectedException.expectCause(Matchers.instanceOf(RuntimeExceptionWithoutStackTrace.class)); result.get(); } |
ServerRestArgsFilter implements HttpServerFilter { @Override public CompletableFuture<Void> beforeSendResponseAsync(Invocation invocation, HttpServletResponseEx responseEx) { Response response = (Response) responseEx.getAttribute(RestConst.INVOCATION_HANDLER_RESPONSE); ProduceProcessor produceProcessor = (ProduceProcessor) responseEx.getAttribute(RestConst.INVOCATION_HANDLER_PROCESSOR); Object body = response.getResult(); if (response.isFailed()) { body = ((InvocationException) body).getErrorData(); } if (null != invocation && isDownloadFileResponseType(invocation, response)) { return responseEx.sendPart(PartUtils.getSinglePart(null, body)); } responseEx.setContentType(produceProcessor.getName() + "; charset=utf-8"); CompletableFuture<Void> future = new CompletableFuture<>(); try (BufferOutputStream output = new BufferOutputStream(Unpooled.compositeBuffer())) { produceProcessor.encodeResponse(output, body); responseEx.setBodyBuffer(output.getBuffer()); future.complete(null); } catch (Throwable e) { future.completeExceptionally(ExceptionFactory.convertProducerException(e)); } return future; } @Override int getOrder(); @Override boolean enabled(); @Override Response afterReceiveRequest(Invocation invocation, HttpServletRequestEx requestEx); @Override CompletableFuture<Void> beforeSendResponseAsync(Invocation invocation, HttpServletResponseEx responseEx); } | @Test public void asyncBeforeSendResponse_part(@Mocked RestOperationMeta restOperationMeta) { ResponsesMeta responsesMeta = new ResponsesMeta(); responsesMeta.getResponseMap().put(202, RestObjectMapperFactory.getRestObjectMapper().constructType(Part.class)); new Expectations(RestMetaUtils.class) { { responseEx.getAttribute(RestConst.INVOCATION_HANDLER_RESPONSE); result = response; response.getResult(); result = part; response.getStatusCode(); result = 202; invocation.findResponseType(202); result = TypeFactory.defaultInstance().constructType(Part.class); } }; new MockUp<HttpServletResponseEx>(responseEx) { @Mock CompletableFuture<Void> sendPart(Part body) { invokedSendPart = true; return null; } }; Assert.assertNull(filter.beforeSendResponseAsync(invocation, responseEx)); Assert.assertTrue(invokedSendPart); } |
RestServerCodecFilter implements Filter { @Override public CompletableFuture<Response> onFilter(Invocation invocation, FilterNode nextNode) { return CompletableFuture.completedFuture(invocation) .thenCompose(this::decodeRequest) .thenCompose(nextNode::onFilter) .exceptionally(exception -> exceptionToResponse(invocation, exception, INTERNAL_SERVER_ERROR)) .thenCompose(response -> encodeResponse(invocation, response)); } @Override CompletableFuture<Response> onFilter(Invocation invocation, FilterNode nextNode); @SuppressWarnings("deprecation") static CompletableFuture<Response> encodeResponse(Response response, boolean download,
ProduceProcessor produceProcessor, HttpServletResponseEx responseEx); static boolean isDownloadFileResponseType(Invocation invocation, Response response); static void copyHeadersToHttpResponse(Map<String, List<Object>> headerMap, HttpServletResponseEx responseEx); } | @Test public void should_not_invoke_filter_when_decode_request_failed(@Mocked FilterNode nextNode) { mockDecodeRequestFail(); codecFilter.onFilter(invocation, nextNode); new Verifications() { { nextNode.onFilter(invocation); times = 0; } }; }
@Test public void should_convert_exception_to_response_when_decode_request_failed() throws ExecutionException, InterruptedException { mockDecodeRequestFail(); new Expectations(invocation) { { invocation.findResponseType(anyInt); result = TypeFactory.defaultInstance().constructType(String.class); } }; Response response = codecFilter.onFilter(invocation, nextNode).get(); assertThat(response.getStatus()).isEqualTo(INTERNAL_SERVER_ERROR); assertThat(Json.encode(response.getResult())) .isEqualTo("{\"code\":\"SCB.50000000\",\"message\":\"encode request failed\"}"); } |
AbstractRestInvocation { public void setHttpServerFilters(List<HttpServerFilter> httpServerFilters) { this.httpServerFilters = httpServerFilters; } AbstractRestInvocation(); void setHttpServerFilters(List<HttpServerFilter> httpServerFilters); String getContext(String key); void invoke(); void sendFailResponse(Throwable throwable); static final String UNKNOWN_OPERATION_ID; } | @Test public void setHttpServerFilters(@Mocked List<HttpServerFilter> httpServerFilters) { restInvocation.setHttpServerFilters(httpServerFilters); Assert.assertSame(httpServerFilters, restInvocation.httpServerFilters); } |
AbstractRestInvocation { protected void initProduceProcessor() { produceProcessor = restOperationMeta.ensureFindProduceProcessor(requestEx); if (produceProcessor == null) { LOGGER.error("Accept {} is not supported, operation={}.", requestEx.getHeader(HttpHeaders.ACCEPT), restOperationMeta.getOperationMeta().getMicroserviceQualifiedName()); String msg = String.format("Accept %s is not supported", requestEx.getHeader(HttpHeaders.ACCEPT)); throw new InvocationException(Status.NOT_ACCEPTABLE, msg); } } AbstractRestInvocation(); void setHttpServerFilters(List<HttpServerFilter> httpServerFilters); String getContext(String key); void invoke(); void sendFailResponse(Throwable throwable); static final String UNKNOWN_OPERATION_ID; } | @Test public void initProduceProcessorNull() { new Expectations() { { requestEx.getHeader(HttpHeaders.ACCEPT); result = "notExistType"; } }; restInvocation = new AbstractRestInvocationForTest() { @Override public void sendFailResponse(Throwable throwable) { } }; initRestInvocation(); expectedException.expect(InvocationException.class); expectedException .expectMessage( "InvocationException: code=406;msg=CommonExceptionData [message=Accept notExistType is not supported]"); restInvocation.initProduceProcessor(); }
@Test public void initProduceProcessorNormal() { new Expectations() { { requestEx.getHeader(HttpHeaders.ACCEPT); result = MediaType.APPLICATION_JSON; } }; restInvocation.initProduceProcessor(); } |
AbstractRestInvocation { public String getContext(String key) { if (null == invocation || null == invocation.getContext()) { return null; } return invocation.getContext(key); } AbstractRestInvocation(); void setHttpServerFilters(List<HttpServerFilter> httpServerFilters); String getContext(String key); void invoke(); void sendFailResponse(Throwable throwable); static final String UNKNOWN_OPERATION_ID; } | @Test public void getContext() { invocation.addContext("key", "test"); assertEquals("test", restInvocation.getContext("key")); }
@Test public void getContextNull() { Assert.assertNull(restInvocation.getContext("key")); } |
AbstractRestInvocation { public void invoke() { try { Response response = prepareInvoke(); if (response != null) { sendResponseQuietly(response); return; } doInvoke(); } catch (Throwable e) { LOGGER.error("unknown rest exception.", e); sendFailResponse(e); } } AbstractRestInvocation(); void setHttpServerFilters(List<HttpServerFilter> httpServerFilters); String getContext(String key); void invoke(); void sendFailResponse(Throwable throwable); static final String UNKNOWN_OPERATION_ID; } | @Test public void invokeFilterHaveResponse(@Mocked HttpServerFilter filter) { Response response = Response.ok(""); new Expectations() { { filter.enabled(); result = true; filter.afterReceiveRequest(invocation, requestEx); result = response; } }; Holder<Response> result = new Holder<>(); restInvocation = new AbstractRestInvocationForTest() { @Override protected void doInvoke() { result.value = Response.ok("not run to here"); } @Override protected void sendResponseQuietly(Response response) { result.value = response; } }; initRestInvocation(); restInvocation.httpServerFilters = Arrays.asList(filter); restInvocation.invoke(); Assert.assertSame(response, result.value); }
@Test public void invokeFilterNoResponse(@Mocked HttpServerFilter filter) { new Expectations() { { filter.enabled(); result = true; filter.afterReceiveRequest(invocation, requestEx); result = null; } }; Holder<Boolean> result = new Holder<>(); restInvocation = new AbstractRestInvocationForTest() { @Override protected void doInvoke() { result.value = true; } }; initRestInvocation(); restInvocation.httpServerFilters = Arrays.asList(filter); restInvocation.invoke(); Assert.assertTrue(result.value); }
@Test public void invokeFilterNoResponseDisableFilter(@Mocked HttpServerFilter filter) { new Expectations() { { filter.enabled(); result = false; } }; Holder<Boolean> result = new Holder<>(); restInvocation = new AbstractRestInvocationForTest() { @Override protected void doInvoke() { result.value = true; } }; initRestInvocation(); restInvocation.httpServerFilters = Arrays.asList(filter); restInvocation.invoke(); Assert.assertTrue(result.value); }
@Test public void invokeFilterException(@Mocked HttpServerFilter filter) { Exception error = new RuntimeExceptionWithoutStackTrace(); new Expectations() { { filter.enabled(); result = true; filter.afterReceiveRequest(invocation, requestEx); result = error; } }; Holder<Throwable> result = new Holder<>(); restInvocation = new AbstractRestInvocationForTest() { @Override public void sendFailResponse(Throwable throwable) { result.value = throwable; } @Override protected void doInvoke() { } }; initRestInvocation(); restInvocation.httpServerFilters = Arrays.asList(filter); restInvocation.invoke(); Assert.assertSame(error, result.value); }
@Test public void invokeNormal(@Mocked HttpServerFilter filter) { new Expectations() { { filter.enabled(); result = true; filter.afterReceiveRequest(invocation, requestEx); result = null; } }; restInvocation = new AbstractRestInvocationForTest() { @Override protected void doInvoke() { } @Override public void sendFailResponse(Throwable throwable) { Assert.fail("must not fail"); } }; initRestInvocation(); restInvocation.httpServerFilters = Arrays.asList(filter); restInvocation.invoke(); assertEquals(nanoTime, invocation.getInvocationStageTrace().getStartServerFiltersRequest()); } |
AbstractRestInvocation { public void sendFailResponse(Throwable throwable) { if (produceProcessor == null) { produceProcessor = ProduceProcessorManager.INSTANCE.findDefaultProcessor(); } Response response = Response.createProducerFail(throwable); sendResponseQuietly(response); } AbstractRestInvocation(); void setHttpServerFilters(List<HttpServerFilter> httpServerFilters); String getContext(String key); void invoke(); void sendFailResponse(Throwable throwable); static final String UNKNOWN_OPERATION_ID; } | @Test public void sendFailResponseNoProduceProcessor() { invocation.onStart(0); restInvocation.produceProcessor = null; restInvocation.sendFailResponse(new RuntimeExceptionWithoutStackTrace()); Assert.assertSame(ProduceProcessorManager.INSTANCE.findDefaultJsonProcessor(), restInvocation.produceProcessor); }
@Test public void sendFailResponseHaveProduceProcessor() { Holder<Response> result = new Holder<>(); restInvocation = new AbstractRestInvocationForTest() { @Override protected void doInvoke() { } @Override protected void sendResponseQuietly(Response response) { result.value = response; } }; initRestInvocation(); restInvocation.produceProcessor = ProduceProcessorManager.INSTANCE.findDefaultPlainProcessor(); Throwable e = new InvocationException(Status.BAD_GATEWAY, ""); restInvocation.sendFailResponse(e); Assert.assertSame(e, result.value.getResult()); Assert.assertSame( ProduceProcessorManager.INSTANCE.findDefaultPlainProcessor(), restInvocation.produceProcessor); } |
AbstractRestInvocation { protected void sendResponseQuietly(Response response) { if (invocation != null) { invocation.getInvocationStageTrace().finishHandlersResponse(); } try { sendResponse(response); } catch (Throwable e) { LOGGER.error("Failed to send rest response, operation:{}, request uri:{}", getMicroserviceQualifiedName(), requestEx.getRequestURI(), e); } } AbstractRestInvocation(); void setHttpServerFilters(List<HttpServerFilter> httpServerFilters); String getContext(String key); void invoke(); void sendFailResponse(Throwable throwable); static final String UNKNOWN_OPERATION_ID; } | @Test public void sendResponseQuietlyException(@Mocked Response response) { restInvocation = new AbstractRestInvocationForTest() { @Override protected void doInvoke() { } @Override protected void sendResponse(Response response) { throw new RuntimeExceptionWithoutStackTrace(); } }; initRestInvocation(); restInvocation.sendResponseQuietly(response); }
@Test public void sendResponseQuietlyExceptionOnNullInvocation(@Mocked Response response) { restInvocation = new AbstractRestInvocationForTest() { @Override protected void doInvoke() { } @Override protected void sendResponse(Response response) { throw new RuntimeExceptionWithoutStackTrace(""); } }; initRestInvocation(); restInvocation.invocation = null; restInvocation.sendResponseQuietly(response); } |
IpPortManager { public IpPort getAvailableAddress() { return getAvailableAddress(currentAvailableIndex.get()); } IpPortManager(ServiceRegistryConfig serviceRegistryConfig); void setAutoDiscoveryInited(boolean autoDiscoveryInited); int getMaxRetryTimes(); void initAutoDiscovery(); IpPort getNextAvailableAddress(IpPort failedIpPort); IpPort getAvailableAddress(); } | @Test public void testGetAvailableAddress(@Injectable ServiceRegistryConfig config, @Injectable InstanceCacheManager cacheManager, @Injectable InstanceCache cache) { ArrayList<IpPort> ipPortList = new ArrayList<>(); ipPortList.add(new IpPort("127.0.0.1", 9980)); ipPortList.add(new IpPort("127.0.0.1", 9981)); new Expectations() { { config.getIpPort(); result = ipPortList; config.getTransport(); result = "rest"; config.isRegistryAutoDiscovery(); result = true; } }; IpPortManager manager = new IpPortManager(config); manager.instanceCacheManager = cacheManager; IpPort address1 = manager.getAvailableAddress(); if (address1.getPort() == 9980) { Assert.assertEquals("127.0.0.1", address1.getHostOrIp()); Assert.assertEquals(9980, address1.getPort()); } else { Assert.assertEquals("127.0.0.1", address1.getHostOrIp()); Assert.assertEquals(9981, address1.getPort()); } IpPort address2 = manager.getNextAvailableAddress(address1); if (address1.getPort() == 9980) { Assert.assertEquals("127.0.0.1", address2.getHostOrIp()); Assert.assertEquals(9981, address2.getPort()); } else { Assert.assertEquals("127.0.0.1", address2.getHostOrIp()); Assert.assertEquals(9980, address2.getPort()); } IpPort address3 = manager.getAvailableAddress(); if (address1.getPort() == 9980) { Assert.assertEquals("127.0.0.1", address3.getHostOrIp()); Assert.assertEquals(9981, address3.getPort()); } else { Assert.assertEquals("127.0.0.1", address3.getHostOrIp()); Assert.assertEquals(9980, address3.getPort()); } Map<String, List<CacheEndpoint>> addresses = new HashMap<>(); List<CacheEndpoint> instances = new ArrayList<>(); instances.add(new CacheEndpoint("http: addresses.put("rest", instances); new Expectations() { { cacheManager.getOrCreate("default", "SERVICECENTER", "latest"); result = cache; cache.getOrCreateTransportMap(); result = addresses; } }; manager.initAutoDiscovery(); IpPort address4 = manager.getNextAvailableAddress(address3); if (address1.getPort() == 9980) { Assert.assertEquals("127.0.0.1", address4.getHostOrIp()); Assert.assertEquals(9980, address4.getPort()); } else { address4 = manager.getNextAvailableAddress(address1); Assert.assertEquals("127.0.0.1", address4.getHostOrIp()); Assert.assertEquals(9980, address4.getPort()); } IpPort address5 = manager.getNextAvailableAddress(address4); Assert.assertEquals("127.0.0.1", address5.getHostOrIp()); Assert.assertEquals(9981, address5.getPort()); manager.setAutoDiscoveryInited(true); IpPort address6 = manager.getNextAvailableAddress(address3); if (address1.getPort() == 9980) { Assert.assertEquals("127.0.0.1", address6.getHostOrIp()); Assert.assertEquals(9982, address6.getPort()); } else { address6 = manager.getNextAvailableAddress(address1); Assert.assertEquals("127.0.0.1", address6.getHostOrIp()); Assert.assertEquals(9982, address6.getPort()); } } |
SecurityModule implements Module { @Override public String getModuleName() { return "security"; } protected SecurityModule(); protected SecurityModule(SecurityConfig config); DataRoomMatcher getDataRoomMatcher(); static SecurityModule newServerModule(SecurityConfig config); static SecurityModule newClientModule(); void setEnabled(final boolean enabled); boolean isEnabled(); void setEnabled(Supplier<Boolean> enabled); @Override String getModuleName(); void reconfigure(SecurityConfig config); SecurityConfig getConfig(); @Override void setupModule(ModuleContext context); boolean isAllowed(QueryContext queryContext, Class<?> resourceClass, ResourcePermission permission); boolean isAllowed(QueryContext queryContext, String resourceType, ResourcePermission permission); ResourcePermission getCallerPermissions(QueryContext queryContext, String resourceType); ResourcePermission getRolePermissions(QueryContext queryContext, String resourceType, String checkedRole); ResourcePermission getResourcePermission(QueryContext queryContext, Class<?> resourceClass); ResourcePermission getResourcePermission(QueryContext queryContext, String resourceType); boolean isUserInRole(QueryContext queryContext, String role); SecurityProvider getCallerSecurityProvider(); } | @Test public void testModuleName() { Assert.assertEquals("security", securityModule.getModuleName()); } |
JpaEntityRepositoryBase extends JpaRepositoryBase<T> implements ResourceRepository<T, I>,
ResourceRegistryAware { @Override public T findOne(I id, QuerySpec querySpec) { String idField = getIdField().getUnderlyingName(); QuerySpec idQuerySpec = querySpec.clone(); idQuerySpec.addFilter(new FilterSpec(Arrays.asList(idField), FilterOperator.EQ, id)); List<T> results = findAll(idQuerySpec); return getUnique(results, id); } JpaEntityRepositoryBase(Class<T> entityClass); JpaEntityRepositoryBase(JpaRepositoryConfig<T> config); JpaQueryFactory getQueryFactory(); @Override T findOne(I id, QuerySpec querySpec); @Override ResourceList<T> findAll(Collection<I> ids, QuerySpec querySpec); @Override ResourceList<T> findAll(QuerySpec querySpec); @Override S create(S resource); @Override S save(S resource); @Override void delete(I id); @Override Class<T> getResourceClass(); Class<?> getEntityClass(); @Override void setResourceRegistry(ResourceRegistry resourceRegistry); ResourceField getIdField(); } | @Test public void testFindOne() { QuerySpec querySpec = new QuerySpec(TestEntity.class); TestEntity entity = repo.findOne(1L, querySpec); Assert.assertEquals("test1", entity.getStringValue()); } |
JpaEntityRepositoryBase extends JpaRepositoryBase<T> implements ResourceRepository<T, I>,
ResourceRegistryAware { @Override public ResourceList<T> findAll(Collection<I> ids, QuerySpec querySpec) { String idField = getIdField().getUnderlyingName(); QuerySpec idQuerySpec = querySpec.clone(); idQuerySpec.addFilter(new FilterSpec(Arrays.asList(idField), FilterOperator.EQ, ids)); return findAll(idQuerySpec); } JpaEntityRepositoryBase(Class<T> entityClass); JpaEntityRepositoryBase(JpaRepositoryConfig<T> config); JpaQueryFactory getQueryFactory(); @Override T findOne(I id, QuerySpec querySpec); @Override ResourceList<T> findAll(Collection<I> ids, QuerySpec querySpec); @Override ResourceList<T> findAll(QuerySpec querySpec); @Override S create(S resource); @Override S save(S resource); @Override void delete(I id); @Override Class<T> getResourceClass(); Class<?> getEntityClass(); @Override void setResourceRegistry(ResourceRegistry resourceRegistry); ResourceField getIdField(); } | @Test public void testFindAllById() { QuerySpec querySpec = new QuerySpec(TestEntity.class); ResourceList<TestEntity> entities = repo.findAll(Arrays.asList(1L, 2L), querySpec); Assert.assertEquals(2, entities.size()); Assert.assertEquals("test1", entities.get(0).getStringValue()); Assert.assertEquals("test2", entities.get(1).getStringValue()); }
@Test(expected = IllegalArgumentException.class) public void testInvalidLimit() { QuerySpec querySpec = new QuerySpec(TestEntity.class); querySpec.setLimit(Long.MAX_VALUE); repo.findAll(querySpec); }
@Test(expected = IllegalArgumentException.class) public void testInvalidOffset() { QuerySpec querySpec = new QuerySpec(TestEntity.class); querySpec.setOffset(Long.MAX_VALUE); repo.findAll(querySpec); }
@Test public void testFilterString() { QuerySpec querySpec = new QuerySpec(TestEntity.class); querySpec.addFilter(new FilterSpec(Arrays.asList("stringValue"), FilterOperator.EQ, "test1")); List<TestEntity> list = repo.findAll(querySpec); Assert.assertEquals(1, list.size()); TestEntity entity = list.get(0); Assert.assertEquals("test1", entity.getStringValue()); }
@Test public void testFilterLong() { QuerySpec querySpec = new QuerySpec(TestEntity.class); querySpec.addFilter(new FilterSpec(Arrays.asList("longValue"), FilterOperator.EQ, 2L)); List<TestEntity> list = repo.findAll(querySpec); Assert.assertEquals(1, list.size()); TestEntity entity = list.get(0); Assert.assertEquals(2, entity.getId().longValue()); Assert.assertEquals(2L, entity.getLongValue()); }
@Test public void testFilterInt() { QuerySpec querySpec = new QuerySpec(TestEntity.class); querySpec.addFilter(new FilterSpec(Arrays.asList("embValue", "embIntValue"), FilterOperator.EQ, 2)); List<TestEntity> list = repo.findAll(querySpec); Assert.assertEquals(1, list.size()); TestEntity entity = list.get(0); Assert.assertEquals(2L, entity.getId().longValue()); Assert.assertEquals(2, entity.getEmbValue().getEmbIntValue().intValue()); }
@Test public void testFilterBooleanTrue() { QuerySpec querySpec = new QuerySpec(TestEntity.class); querySpec.addFilter( new FilterSpec(Arrays.asList("embValue", "nestedValue", "embBoolValue"), FilterOperator.EQ, true)); List<TestEntity> list = repo.findAll(querySpec); Assert.assertEquals(1, list.size()); TestEntity entity = list.get(0); Assert.assertTrue(entity.getEmbValue().getNestedValue().getEmbBoolValue()); }
@Test public void testFilterBooleanFalse() { QuerySpec querySpec = new QuerySpec(TestEntity.class); querySpec.addFilter( new FilterSpec(Arrays.asList("embValue", "nestedValue", "embBoolValue"), FilterOperator.EQ, false)); List<TestEntity> list = repo.findAll(querySpec); Assert.assertEquals(numTestEntities - 1, list.size()); for (TestEntity entity : list) { Assert.assertFalse(entity.getEmbValue().getNestedValue().getEmbBoolValue()); } }
@Test public void testFilterEquals() { QuerySpec querySpec = new QuerySpec(TestEntity.class); querySpec.addFilter(new FilterSpec(Arrays.asList("longValue"), FilterOperator.EQ, 2L)); List<TestEntity> list = repo.findAll(querySpec); Assert.assertEquals(1, list.size()); }
@Test public void testFilterNotEquals() { QuerySpec querySpec = new QuerySpec(TestEntity.class); querySpec.addFilter(new FilterSpec(Arrays.asList("longValue"), FilterOperator.NEQ, 2L)); List<TestEntity> list = repo.findAll(querySpec); Assert.assertEquals(4, list.size()); }
@Test public void testFilterLess() { QuerySpec querySpec = new QuerySpec(TestEntity.class); querySpec.addFilter(new FilterSpec(Arrays.asList("longValue"), FilterOperator.LT, 2)); List<TestEntity> list = repo.findAll(querySpec); Assert.assertEquals(2, list.size()); }
@Test public void testFilterLessEqual() { QuerySpec querySpec = new QuerySpec(TestEntity.class); querySpec.addFilter(new FilterSpec(Arrays.asList("longValue"), FilterOperator.LE, 2)); List<TestEntity> list = repo.findAll(querySpec); Assert.assertEquals(3, list.size()); }
@Test public void testFilterGreater() { QuerySpec querySpec = new QuerySpec(TestEntity.class); querySpec.addFilter(new FilterSpec(Arrays.asList("longValue"), FilterOperator.GT, 1)); List<TestEntity> list = repo.findAll(querySpec); Assert.assertEquals(3, list.size()); }
@Test public void testFilterGreaterEqual() { QuerySpec querySpec = new QuerySpec(TestEntity.class); querySpec.addFilter(new FilterSpec(Arrays.asList("longValue"), FilterOperator.GE, 1)); List<TestEntity> list = repo.findAll(querySpec); Assert.assertEquals(4, list.size()); }
@Test public void testFilterLike() { QuerySpec querySpec = new QuerySpec(TestEntity.class); querySpec.addFilter(new FilterSpec(Arrays.asList("stringValue"), FilterOperator.LIKE, "test2")); List<TestEntity> list = repo.findAll(querySpec); Assert.assertEquals(1, list.size()); }
@Test public void testFilterLikeWildcards() { QuerySpec querySpec = new QuerySpec(TestEntity.class); querySpec.addFilter(new FilterSpec(Arrays.asList("stringValue"), FilterOperator.LIKE, "test%")); List<TestEntity> list = repo.findAll(querySpec); Assert.assertEquals(5, list.size()); }
@Test public void testPaging() { QuerySpec querySpec = new QuerySpec(TestEntity.class); querySpec.setOffset(2L); querySpec.setLimit(2L); ResourceList<TestEntity> list = repo.findAll(querySpec); Assert.assertEquals(2, list.size()); Assert.assertEquals(2, list.get(0).getId().intValue()); Assert.assertEquals(3, list.get(1).getId().intValue()); PagedMetaInformation metaInformation = list.getMeta(PagedMetaInformation.class); Assert.assertEquals(5, metaInformation.getTotalResourceCount().longValue()); }
@Test public void testPagingFirst() { QuerySpec querySpec = new QuerySpec(TestEntity.class); querySpec.setOffset(0L); querySpec.setLimit(3L); ResourceList<TestEntity> list = repo.findAll(querySpec); Assert.assertEquals(3, list.size()); Assert.assertEquals(0, list.get(0).getId().intValue()); Assert.assertEquals(1, list.get(1).getId().intValue()); Assert.assertEquals(2, list.get(2).getId().intValue()); PagedMetaInformation metaInformation = list.getMeta(PagedMetaInformation.class); Assert.assertEquals(5, metaInformation.getTotalResourceCount().longValue()); }
@Test public void testPagingLast() { QuerySpec querySpec = new QuerySpec(TestEntity.class); querySpec.setOffset(4L); querySpec.setLimit(4L); ResourceList<TestEntity> list = repo.findAll(querySpec); Assert.assertEquals(1, list.size()); Assert.assertEquals(4, list.get(0).getId().intValue()); PagedMetaInformation metaInformation = list.getMeta(PagedMetaInformation.class); Assert.assertEquals(5, metaInformation.getTotalResourceCount().longValue()); }
@Test public void testPagingLargeLimit() { QuerySpec querySpec = new QuerySpec(TestEntity.class); querySpec.setOffset(1L); querySpec.setLimit(10L); ResourceList<TestEntity> list = repo.findAll(querySpec); Assert.assertEquals(4, list.size()); PagedMetaInformation metaInformation = list.getMeta(PagedMetaInformation.class); Assert.assertEquals(5, metaInformation.getTotalResourceCount().longValue()); }
@Test public void testOffserAndNoLimit() { QuerySpec querySpec = new QuerySpec(TestEntity.class); querySpec.setOffset(1L); querySpec.setLimit(null); ResourceList<TestEntity> list = repo.findAll(querySpec); Assert.assertEquals(4, list.size()); PagedMetaInformation metaInformation = list.getMeta(PagedMetaInformation.class); Assert.assertEquals(5, metaInformation.getTotalResourceCount().longValue()); }
@Test public void testIncludeNoRelations() { em.clear(); List<TestEntity> list = repo.findAll(new QuerySpec(TestEntity.class)); Assert.assertEquals(numTestEntities, list.size()); for (TestEntity entity : list) { RelatedEntity relatedValue = entity.getOneRelatedValue(); if (relatedValue != null) { Assert.assertFalse(Hibernate.isInitialized(relatedValue)); } } }
@Test(expected = Exception.class) public void testFilterUnknownAttr() { QuerySpec querySpec = new QuerySpec(TestEntity.class); querySpec.addFilter(new FilterSpec(Arrays.asList("test"), FilterOperator.EQ, "test")); repo.findAll(querySpec); }
@Test(expected = Exception.class) public void testSortUnknownAttr() { QuerySpec querySpec = new QuerySpec(TestEntity.class); querySpec.addSort(new SortSpec(Arrays.asList("test"), Direction.DESC)); repo.findAll(querySpec); }
@Test public void testFindAll() { QuerySpec querySpec = new QuerySpec(TestEntity.class); List<TestEntity> list = repo.findAll(querySpec); Assert.assertEquals(numTestEntities, list.size()); } |
JpaEntityRepositoryBase extends JpaRepositoryBase<T> implements ResourceRepository<T, I>,
ResourceRegistryAware { protected QuerySpec optimizeQuerySpec(QuerySpec filteredQuerySpec) { QuerySpec clone = filteredQuerySpec.clone(); String resourceType = filteredQuerySpec.getResourceType(); RegistryEntry entry = resourceType != null ? resourceRegistry.getEntry(resourceType) : resourceRegistry.getEntry(filteredQuerySpec.getResourceClass()); ResourceInformation resourceInformation = entry.getResourceInformation(); List<FilterSpec> filters = clone.getFilters(); for (FilterSpec filter : filters) { PathSpec path = filter.getPath(); if (path == null || path.getElements().size() < 2) { continue; } List<String> elements = path.getElements(); String attr1 = elements.get(elements.size() - 2); String attr2 = elements.get(elements.size() - 1); ResourceField firstField = resourceInformation.findFieldByUnderlyingName(attr1); if (firstField != null && firstField.getResourceFieldType() == ResourceFieldType.RELATIONSHIP && firstField.hasIdField() && isRequestingOppositeId(firstField, attr2)) { PathSpec optimizedPath = PathSpec.of(elements.subList(0, elements.size() - 2)).append(firstField.getIdName()); filter.setPath(optimizedPath); } } return clone; } JpaEntityRepositoryBase(Class<T> entityClass); JpaEntityRepositoryBase(JpaRepositoryConfig<T> config); JpaQueryFactory getQueryFactory(); @Override T findOne(I id, QuerySpec querySpec); @Override ResourceList<T> findAll(Collection<I> ids, QuerySpec querySpec); @Override ResourceList<T> findAll(QuerySpec querySpec); @Override S create(S resource); @Override S save(S resource); @Override void delete(I id); @Override Class<T> getResourceClass(); Class<?> getEntityClass(); @Override void setResourceRegistry(ResourceRegistry resourceRegistry); ResourceField getIdField(); } | @Test public void testOptimization() { QuerySpec querySpec = new QuerySpec(RelationIdEntity.class); querySpec.addFilter(PathSpec.of("oneRelatedValue", "id").filter(FilterOperator.EQ, 1L)); QuerySpec optimized = repo.optimizeQuerySpec(querySpec); Assert.assertEquals(1, optimized.getFilters().size()); FilterSpec filterSpec = optimized.getFilters().get(0); Assert.assertEquals(PathSpec.of("oneRelatedValueId"), filterSpec.getPath()); } |
ResourcePermission { public static ResourcePermission fromMethod(HttpMethod method) { ResourcePermission permission = METHODS.get(method); PreconditionUtil.verify(permission != null, "unknown method %s, expected=%s", method, METHODS); return permission; } protected ResourcePermission(); private ResourcePermission(boolean post, boolean get, boolean patch, boolean delete); static final ResourcePermission create(boolean push, boolean get, boolean patch, boolean delete); static ResourcePermission fromMethod(HttpMethod method); boolean isPostAllowed(); boolean isGetAllowed(); boolean isPatchAllowed(); boolean isDeleteAllowed(); @JsonIgnore boolean isEmpty(); ResourcePermission or(ResourcePermission other); ResourcePermission and(ResourcePermission other); ResourcePermission xor(ResourcePermission other); @Override int hashCode(); @Override boolean equals(Object obj); @Override String toString(); static final ResourcePermission EMPTY; static final ResourcePermission ALL; static final ResourcePermission GET; static final ResourcePermission POST; static final ResourcePermission PATCH; static final ResourcePermission DELETE; } | @Test public void fromMethod() { Assert.assertEquals(ResourcePermission.GET, ResourcePermission.fromMethod(HttpMethod.GET)); Assert.assertEquals(ResourcePermission.POST, ResourcePermission.fromMethod(HttpMethod.POST)); Assert.assertEquals(ResourcePermission.DELETE, ResourcePermission.fromMethod(HttpMethod.DELETE)); Assert.assertEquals(ResourcePermission.PATCH, ResourcePermission.fromMethod(HttpMethod.PATCH)); } |
ResourcePermission { @Override public String toString() { return "ResourcePermission[post=" + postAllowed + ", get=" + getAllowed + ", patch=" + patchAllowed + ", delete=" + deleteAllowed + "]"; } protected ResourcePermission(); private ResourcePermission(boolean post, boolean get, boolean patch, boolean delete); static final ResourcePermission create(boolean push, boolean get, boolean patch, boolean delete); static ResourcePermission fromMethod(HttpMethod method); boolean isPostAllowed(); boolean isGetAllowed(); boolean isPatchAllowed(); boolean isDeleteAllowed(); @JsonIgnore boolean isEmpty(); ResourcePermission or(ResourcePermission other); ResourcePermission and(ResourcePermission other); ResourcePermission xor(ResourcePermission other); @Override int hashCode(); @Override boolean equals(Object obj); @Override String toString(); static final ResourcePermission EMPTY; static final ResourcePermission ALL; static final ResourcePermission GET; static final ResourcePermission POST; static final ResourcePermission PATCH; static final ResourcePermission DELETE; } | @Test public void string() { Assert.assertEquals("ResourcePermission[post=false, get=true, patch=false, delete=false]", ResourcePermission.GET.toString()); } |
JpaClientModuleFactory implements ClientModuleFactory { @Override public JpaModule create() { return JpaModule.newClientModule(); } @Override JpaModule create(); } | @Test public void test() { ServiceLoader<ClientModuleFactory> loader = ServiceLoader.load(ClientModuleFactory.class); Iterator<ClientModuleFactory> iterator = loader.iterator(); Set<Class> moduleClasses = new HashSet<>(); while (iterator.hasNext()) { ClientModuleFactory moduleFactory = iterator.next(); Module module = moduleFactory.create(); moduleClasses.add(module.getClass()); } Assert.assertEquals(2, moduleClasses.size()); Assert.assertTrue(moduleClasses.contains(JpaModule.class)); Assert.assertTrue(moduleClasses.contains(MetaModule.class)); } |
QuerydslUtils { @SuppressWarnings("unchecked") public static <T> EntityPath<T> getEntityPath(Class<T> entityClass) { Class<?> queryClass = getQueryClass(entityClass); try { String fieldName = firstToLower(entityClass.getSimpleName()); Field field = queryClass.getField(fieldName); return (EntityPath<T>) field.get(entityClass); } catch (NoSuchFieldException | SecurityException | IllegalArgumentException | IllegalAccessException e) { throw new IllegalStateException("failed to access query class " + queryClass.getName(), e); } } private QuerydslUtils(); @SuppressWarnings("unchecked") static EntityPath<T> getEntityPath(Class<T> entityClass); @SuppressWarnings("unchecked") static Expression<T> get(Expression<?> path, String name); static com.querydsl.core.JoinType convertJoinType(JoinType joinType); static boolean hasManyRootsFetchesOrJoins(JPAQuery<?> query); static Class<?> getQueryClass(Class<?> entityClass); } | @Test(expected = IllegalStateException.class) public void throwExceptionWhenAccessingInvalidEntityPath() { QuerydslUtils.getEntityPath(InvalidEntity.class); } |
QuerydslUtils { public static Class<?> getQueryClass(Class<?> entityClass) { String queryClassName = entityClass.getPackage().getName() + ".Q" + entityClass.getSimpleName(); try { return entityClass.getClassLoader().loadClass(queryClassName); } catch (ClassNotFoundException | SecurityException | IllegalArgumentException e) { throw new IllegalStateException("unable to find query class " + queryClassName, e); } } private QuerydslUtils(); @SuppressWarnings("unchecked") static EntityPath<T> getEntityPath(Class<T> entityClass); @SuppressWarnings("unchecked") static Expression<T> get(Expression<?> path, String name); static com.querydsl.core.JoinType convertJoinType(JoinType joinType); static boolean hasManyRootsFetchesOrJoins(JPAQuery<?> query); static Class<?> getQueryClass(Class<?> entityClass); } | @Test(expected = IllegalStateException.class) public void throwExceptionWhenGettingInvalidQueryClass() { QuerydslUtils.getQueryClass(InvalidEntity.class); } |
QuerydslUtils { @SuppressWarnings("unchecked") public static <T> Expression<T> get(Expression<?> path, String name) { try { Class<?> clazz = path.getClass(); Field field = clazz.getField(name); return (Expression<T>) field.get(path); } catch (NoSuchFieldException | SecurityException | IllegalArgumentException | IllegalAccessException e) { throw new IllegalStateException("failed get field " + path + "." + name, e); } } private QuerydslUtils(); @SuppressWarnings("unchecked") static EntityPath<T> getEntityPath(Class<T> entityClass); @SuppressWarnings("unchecked") static Expression<T> get(Expression<?> path, String name); static com.querydsl.core.JoinType convertJoinType(JoinType joinType); static boolean hasManyRootsFetchesOrJoins(JPAQuery<?> query); static Class<?> getQueryClass(Class<?> entityClass); } | @Test(expected = IllegalStateException.class) public void throwExceptionWhenFollowingInvalidPath() { Expression<?> expression = Mockito.mock(Expression.class); Mockito.when(expression.getType()).thenReturn((Class) InvalidEntity.class); QuerydslUtils.get(expression, "doesNotExist"); } |
ConstraintViolationImpl implements ConstraintViolation<Object> { @Override public String getMessage() { return errorData.getDetail(); } private ConstraintViolationImpl(ResourceRegistry resourceRegistry, ErrorData errorData, QueryContext queryContext); static ConstraintViolationImpl fromError(ResourceRegistry resourceRegistry, ErrorData error, QueryContext queryContext); ErrorData getErrorData(); Serializable getResourceId(); @Override Object getRootBean(); @Override Object getLeafBean(); @Override Object getInvalidValue(); @Override Object[] getExecutableParameters(); @Override Object getExecutableReturnValue(); @Override String getMessage(); @Override ConstraintDescriptor<?> getConstraintDescriptor(); @Override String getMessageTemplate(); @Override Path getPropertyPath(); @SuppressWarnings({"rawtypes", "unchecked"}) @Override Class getRootBeanClass(); @Override U unwrap(Class<U> arg0); } | @Test public void testDetailMappedToMessage() { Assert.assertEquals(errorData.getDetail(), violation.getMessage()); Assert.assertNotNull(errorData.getDetail()); }
@Test public void getMessage() { violation.getMessage(); Mockito.verify(errorData, Mockito.times(1)).getDetail(); } |
QueryFactoryDiscovery { public JpaQueryFactory discoverDefaultFactory() { if (ClassUtils.existsClass("com.querydsl.jpa.impl.JPAQuery")) { return QuerydslQueryFactory.newInstance(); } else { return JpaCriteriaQueryFactory.newInstance(); } } JpaQueryFactory discoverDefaultFactory(); } | @Test public void checkDiscoverQueryDsl() { QueryFactoryDiscovery discovery = new QueryFactoryDiscovery(); Assert.assertEquals(QuerydslQueryFactory.class, discovery.discoverDefaultFactory().getClass()); }
@Test public void checkDiscoverCriteriaApi() { QueryFactoryDiscovery discovery = new QueryFactoryDiscovery(); ClassLoader bootstrapClassLoader = ClassLoader.getSystemClassLoader().getParent(); ClassLoader contextClassLoader = Thread.currentThread().getContextClassLoader(); Thread.currentThread().setContextClassLoader(bootstrapClassLoader); try { Assert.assertEquals(JpaCriteriaQueryFactory.class, discovery.discoverDefaultFactory().getClass()); } finally { Thread.currentThread().setContextClassLoader(contextClassLoader); } } |
JpaFacetProvider extends FacetProviderBase implements Prioritizable { @Override public List<FacetValue> findValues(FacetInformation facetInformation, QuerySpec querySpec) { if (facetInformation instanceof BasicFacetInformation) { String resourceType = facetInformation.getResource().getResourceType(); ResourceRepository repository = (ResourceRepository) context.getEntry(resourceType).getResourceRepository().getImplementation(); JpaEntityRepositoryBase entityRepository = (JpaEntityRepositoryBase) unwrap(repository); BasicFacetInformation basicFacetInformation = (BasicFacetInformation) facetInformation; PathSpec path = basicFacetInformation.getPath(); TypeParser typeParser = context.getTypeParser(); Map<Object, FacetValue> facetValueMap = new HashMap<>(); JpaQueryFactory queryFactory = entityRepository.getQueryFactory(); Class entityClass = entityRepository.getEntityClass(); JpaCriteriaQueryImpl query = (JpaCriteriaQueryImpl) queryFactory.query(entityClass); query.setPrivateData(new JpaRequestContext(entityRepository, querySpec)); QuerySpec filteredQuerySpec = JpaRepositoryUtils.filterQuerySpec(entityRepository.getRepositoryConfig(), entityRepository, querySpec); JpaRepositoryUtils.prepareQuery(query, filteredQuerySpec, Collections.emptySet()); JpaCriteriaQueryBackend backend = query.newBackend(); CriteriaQuery criteriaQuery = backend.getCriteriaQuery(); QueryBuilder executorFactory = new QueryBuilder(query, backend); executorFactory.applyFilterSpec(); Expression expression = (Expression) executorFactory.getExpression(path); criteriaQuery.groupBy(expression); CriteriaBuilder criteriaBuilder = backend.getCriteriaBuilder(); Expression<Long> countExpr = criteriaBuilder.count(expression); criteriaQuery.multiselect(expression, countExpr); TypedQuery typedQuery = queryFactory.getEntityManager().createQuery(criteriaQuery); List<Object[]> resultList = typedQuery.getResultList(); for (Object[] result : resultList) { Object value = result[0]; Long count = (Long) result[1]; String label = typeParser.toString(value); FacetValue facetValue = new FacetValue(); facetValue.setValue(value); facetValue.setLabel(label); facetValue.setCount(count); facetValue.setFilterSpec(path.filter(FilterOperator.EQ, value)); facetValueMap.put(value, facetValue); } return toList(facetValueMap); } else { throw new UnsupportedOperationException("unknown facet type: " + facetInformation); } } @Override boolean accepts(RegistryEntry entry); @Override List<FacetValue> findValues(FacetInformation facetInformation, QuerySpec querySpec); @Override int getPriority(); } | @Test(expected = UnsupportedOperationException.class) public void checkUnknownFacet() { JpaFacetProvider facetProvider = new JpaFacetProvider(); QuerySpec querySpec = Mockito.mock(QuerySpec.class); FacetInformation facetInformation = Mockito.mock(FacetInformation.class); facetProvider.findValues(facetInformation, querySpec); } |
JpaModule implements InitializingModule { public static JpaModule createServerModule(JpaModuleConfig config, EntityManager em, TransactionRunner transactionRunner) { return createServerModule(config, () -> em, transactionRunner); } protected JpaModule(); private JpaModule(JpaModuleConfig config, EntityManagerFactory emFactory, Supplier<EntityManager> em, TransactionRunner
transactionRunner); static JpaModule newClientModule(); static JpaModule createServerModule(JpaModuleConfig config, EntityManager em, TransactionRunner transactionRunner); static JpaModule createServerModule(JpaModuleConfig config, Supplier<EntityManager> em, TransactionRunner transactionRunner); @Override String getModuleName(); @Override void setupModule(ModuleContext context); @Override void init(); EntityManager getEntityManager(); EntityManagerFactory getEntityManagerFactory(); MetaLookup getJpaMetaLookup(); boolean hasRepository(Class<?> resourceClass); JpaMetaProvider getJpaMetaProvider(); JpaModuleConfig getConfig(); } | @Test public void checkInvalidConfig() { JpaModuleConfig config = new JpaModuleConfig(); config.addRepository(JpaRepositoryConfig.create(String.class)); CrnkBoot boot = new CrnkBoot(); EntityManager em = Mockito.mock(EntityManager.class); TransactionRunner transactionManager = Mockito.mock(TransactionRunner.class); boot.addModule(JpaModule.createServerModule(config, em, transactionManager)); try { boot.boot(); } catch (IllegalStateException e) { Assert.assertEquals(e.getMessage(), "failed to gather entity informations from class java.lang.String, make sure it is probably annotated with " + "JPA annotations"); } } |
Operation { @Override public boolean equals(Object o) { if (o != null && getClass() == o.getClass()) { Operation operation = (Operation) o; return CompareUtils.isEquals(op, operation.op) && CompareUtils.isEquals(path, operation.path) && CompareUtils.isEquals(value, operation.value); } return false; } Operation(); Operation(String op, String path, Resource value); String getOp(); void setOp(String op); String getPath(); void setPath(String path); Resource getValue(); void setValue(Resource value); @Override boolean equals(Object o); @Override int hashCode(); } | @Test public void testEquals() { EqualsVerifier.forClass(Operation.class).usingGetClass().suppress(Warning.NONFINAL_FIELDS).verify(); } |
Operation { @Override public int hashCode() { int result = op != null ? op.hashCode() : 0; result = 31 * result + (path != null ? path.hashCode() : 0); result = 31 * result + (value != null ? value.hashCode() : 0); return result; } Operation(); Operation(String op, String path, Resource value); String getOp(); void setOp(String op); String getPath(); void setPath(String path); Resource getValue(); void setValue(Resource value); @Override boolean equals(Object o); @Override int hashCode(); } | @Test public void testHashCode() { Operation op1 = new Operation("a", "b", new Resource()); Operation op2 = new Operation("a", "b", new Resource()); Operation op3 = new Operation("x", "b", new Resource()); Assert.assertEquals(op1, op2); Assert.assertNotEquals(op3.hashCode(), op2.hashCode()); } |
PathSpec { public static PathSpec of(String... elements) { return elements != null ? of(Arrays.asList(elements)) : null; } protected PathSpec(); protected PathSpec(String path); static PathSpec of(String... elements); static PathSpec of(List<String> elements); static PathSpec empty(); @Override PathSpec clone(); static PathSpec of(String path); List<String> getElements(); void setElements(List<String> elements); String toString(); @Override boolean equals(Object o); @Override int hashCode(); boolean isEmpty(); SortSpec sort(Direction dir); FilterSpec filter(FilterOperator operator, Object value); PathSpec append(String fieldName); } | @Test public void testSerialization() throws IOException { PathSpec pathSpec = PathSpec.of("a.b.c"); ObjectMapper objectMapper = new ObjectMapper(); String json = objectMapper.writerFor(PathSpec.class).writeValueAsString(pathSpec); Assert.assertEquals("\"a.b.c\"", json); PathSpec clone = objectMapper.readerFor(PathSpec.class).readValue(json); Assert.assertEquals(pathSpec, clone); } |
FilterSpec extends AbstractPathSpec implements Comparable<FilterSpec> { @Override public FilterSpec clone() { return new FilterSpec(this); } protected FilterSpec(); FilterSpec(FilterSpec spec); FilterSpec(Object value); FilterSpec(FilterOperator operator, List<FilterSpec> expressions); FilterSpec(List<String> attributePath, FilterOperator operator, Object value); FilterSpec(PathSpec path, FilterOperator operator, Object value); private FilterSpec(PathSpec pathSpec, FilterOperator operator, Object value, List<FilterSpec> expressions); static FilterSpec and(Collection<FilterSpec> conditions); static FilterSpec and(FilterSpec... conditions); static FilterSpec or(Collection<FilterSpec> conditions); static FilterSpec or(FilterSpec... conditions); static FilterSpec not(FilterSpec expression); FilterOperator getOperator(); void setOperator(FilterOperator operator); T getValue(); void setValue(Object value); List<FilterSpec> getExpression(); void setExpression(List<FilterSpec> expression); FilterSpec addExpression(FilterSpec expr); boolean hasExpressions(); @Override int hashCode(); @Override boolean equals(Object obj); @Override String toString(); FilterSpec normalize(); @Override FilterSpec clone(); @Override int compareTo(FilterSpec o); } | @Test public void testCloneBasic() { FilterSpec spec = new FilterSpec(Arrays.asList("name"), FilterOperator.EQ, "test"); Assert.assertEquals(spec, spec.clone()); } |
FilterSpec extends AbstractPathSpec implements Comparable<FilterSpec> { static List<FilterSpec> cloneExpressions(List<FilterSpec> list, boolean normalize) { List<FilterSpec> result = new ArrayList<>(); for (FilterSpec spec : list) { if (normalize) { result.add(spec.normalize()); } else { result.add(spec.clone()); } } if (normalize) { Collections.sort(result); } return result; } protected FilterSpec(); FilterSpec(FilterSpec spec); FilterSpec(Object value); FilterSpec(FilterOperator operator, List<FilterSpec> expressions); FilterSpec(List<String> attributePath, FilterOperator operator, Object value); FilterSpec(PathSpec path, FilterOperator operator, Object value); private FilterSpec(PathSpec pathSpec, FilterOperator operator, Object value, List<FilterSpec> expressions); static FilterSpec and(Collection<FilterSpec> conditions); static FilterSpec and(FilterSpec... conditions); static FilterSpec or(Collection<FilterSpec> conditions); static FilterSpec or(FilterSpec... conditions); static FilterSpec not(FilterSpec expression); FilterOperator getOperator(); void setOperator(FilterOperator operator); T getValue(); void setValue(Object value); List<FilterSpec> getExpression(); void setExpression(List<FilterSpec> expression); FilterSpec addExpression(FilterSpec expr); boolean hasExpressions(); @Override int hashCode(); @Override boolean equals(Object obj); @Override String toString(); FilterSpec normalize(); @Override FilterSpec clone(); @Override int compareTo(FilterSpec o); } | @Test public void testCloneExpressions() { FilterSpec spec1 = new FilterSpec(Arrays.asList("name1"), FilterOperator.EQ, "test"); FilterSpec spec2 = new FilterSpec(Arrays.asList("name2"), FilterOperator.EQ, "test"); FilterSpec andSpec = FilterSpec.and(spec1, spec2); Assert.assertEquals(andSpec, andSpec.clone()); } |
FilterSpec extends AbstractPathSpec implements Comparable<FilterSpec> { @Override public String toString() { StringBuilder b = new StringBuilder(); if (getExpression() != null) { int nExprs = getExpression().size(); if (getOperator() == FilterOperator.NOT) { appendNot(b, nExprs); } else { appendExpressions(b, nExprs); } } else if (path != null) { b.append(path); b.append(' '); b.append(operator.name()); b.append(' '); b.append(value); } return b.toString(); } protected FilterSpec(); FilterSpec(FilterSpec spec); FilterSpec(Object value); FilterSpec(FilterOperator operator, List<FilterSpec> expressions); FilterSpec(List<String> attributePath, FilterOperator operator, Object value); FilterSpec(PathSpec path, FilterOperator operator, Object value); private FilterSpec(PathSpec pathSpec, FilterOperator operator, Object value, List<FilterSpec> expressions); static FilterSpec and(Collection<FilterSpec> conditions); static FilterSpec and(FilterSpec... conditions); static FilterSpec or(Collection<FilterSpec> conditions); static FilterSpec or(FilterSpec... conditions); static FilterSpec not(FilterSpec expression); FilterOperator getOperator(); void setOperator(FilterOperator operator); T getValue(); void setValue(Object value); List<FilterSpec> getExpression(); void setExpression(List<FilterSpec> expression); FilterSpec addExpression(FilterSpec expr); boolean hasExpressions(); @Override int hashCode(); @Override boolean equals(Object obj); @Override String toString(); FilterSpec normalize(); @Override FilterSpec clone(); @Override int compareTo(FilterSpec o); } | @Test public void testToString() { Assert.assertEquals("name EQ test", new FilterSpec(Arrays.asList("name"), FilterOperator.EQ, "test").toString()); Assert.assertEquals("name1.name2 EQ test", new FilterSpec(Arrays.asList("name1", "name2"), FilterOperator.EQ, "test").toString()); Assert.assertEquals("name NEQ test", new FilterSpec(Arrays.asList("name"), FilterOperator.NEQ, "test").toString()); Assert.assertEquals("NOT(name NEQ test)", FilterSpec.not(new FilterSpec(Arrays.asList("name"), FilterOperator.NEQ, "test")).toString()); Assert.assertEquals("(name1 NEQ test1) AND (name2 EQ test2)", FilterSpec.and(new FilterSpec(Arrays.asList("name1"), FilterOperator.NEQ, "test1"), new FilterSpec(Arrays.asList("name2"), FilterOperator.EQ, "test2")).toString()); Assert.assertEquals("NOT((name1 NEQ test1) AND (name2 EQ test2))", new FilterSpec(FilterOperator.NOT, Arrays.asList(new FilterSpec(Arrays.asList("name1"), FilterOperator.NEQ, "test1"), new FilterSpec(Arrays.asList("name2"), FilterOperator.EQ, "test2"))).toString()); Assert.assertEquals("NOT(name2 EQ test2)", new FilterSpec(FilterOperator.NOT, Arrays.asList(new FilterSpec(Arrays.asList("name2"), FilterOperator.EQ, "test2"))).toString()); } |
ConstraintViolationImpl implements ConstraintViolation<Object> { @Override public Path getPropertyPath() { return path; } private ConstraintViolationImpl(ResourceRegistry resourceRegistry, ErrorData errorData, QueryContext queryContext); static ConstraintViolationImpl fromError(ResourceRegistry resourceRegistry, ErrorData error, QueryContext queryContext); ErrorData getErrorData(); Serializable getResourceId(); @Override Object getRootBean(); @Override Object getLeafBean(); @Override Object getInvalidValue(); @Override Object[] getExecutableParameters(); @Override Object getExecutableReturnValue(); @Override String getMessage(); @Override ConstraintDescriptor<?> getConstraintDescriptor(); @Override String getMessageTemplate(); @Override Path getPropertyPath(); @SuppressWarnings({"rawtypes", "unchecked"}) @Override Class getRootBeanClass(); @Override U unwrap(Class<U> arg0); } | @Test public void path() { Path path = violation.getPropertyPath(); Assert.assertEquals("name", path.toString()); Assert.assertEquals(path.toString().hashCode(), path.hashCode()); Assert.assertNotEquals(path, null); Assert.assertNotEquals(path, "not a path"); Assert.assertEquals(path, path); Iterator<Path.Node> iterator = path.iterator(); Assert.assertTrue(iterator.hasNext()); Path.Node node = iterator.next(); Assert.assertEquals("name", node.getName()); Assert.assertEquals("name", node.toString()); Assert.assertEquals(null, node.getKey()); Assert.assertEquals(ElementKind.PROPERTY, node.getKind()); try { node.isInIterable(); Assert.fail(); } catch (UnsupportedOperationException e) { } try { node.as((Class) String.class); Assert.fail(); } catch (UnsupportedOperationException e) { } Assert.assertFalse(iterator.hasNext()); } |
FilterSpec extends AbstractPathSpec implements Comparable<FilterSpec> { public static FilterSpec and(Collection<FilterSpec> conditions) { return and(conditions.toArray(new FilterSpec[conditions.size()])); } protected FilterSpec(); FilterSpec(FilterSpec spec); FilterSpec(Object value); FilterSpec(FilterOperator operator, List<FilterSpec> expressions); FilterSpec(List<String> attributePath, FilterOperator operator, Object value); FilterSpec(PathSpec path, FilterOperator operator, Object value); private FilterSpec(PathSpec pathSpec, FilterOperator operator, Object value, List<FilterSpec> expressions); static FilterSpec and(Collection<FilterSpec> conditions); static FilterSpec and(FilterSpec... conditions); static FilterSpec or(Collection<FilterSpec> conditions); static FilterSpec or(FilterSpec... conditions); static FilterSpec not(FilterSpec expression); FilterOperator getOperator(); void setOperator(FilterOperator operator); T getValue(); void setValue(Object value); List<FilterSpec> getExpression(); void setExpression(List<FilterSpec> expression); FilterSpec addExpression(FilterSpec expr); boolean hasExpressions(); @Override int hashCode(); @Override boolean equals(Object obj); @Override String toString(); FilterSpec normalize(); @Override FilterSpec clone(); @Override int compareTo(FilterSpec o); } | @Test public void testAndOneExpr() { FilterSpec spec1 = new FilterSpec(Arrays.asList("name1"), FilterOperator.EQ, "test"); FilterSpec andSpec = FilterSpec.and(spec1); Assert.assertSame(spec1, andSpec); } |
FilterSpec extends AbstractPathSpec implements Comparable<FilterSpec> { public static FilterSpec or(Collection<FilterSpec> conditions) { return or(conditions.toArray(new FilterSpec[conditions.size()])); } protected FilterSpec(); FilterSpec(FilterSpec spec); FilterSpec(Object value); FilterSpec(FilterOperator operator, List<FilterSpec> expressions); FilterSpec(List<String> attributePath, FilterOperator operator, Object value); FilterSpec(PathSpec path, FilterOperator operator, Object value); private FilterSpec(PathSpec pathSpec, FilterOperator operator, Object value, List<FilterSpec> expressions); static FilterSpec and(Collection<FilterSpec> conditions); static FilterSpec and(FilterSpec... conditions); static FilterSpec or(Collection<FilterSpec> conditions); static FilterSpec or(FilterSpec... conditions); static FilterSpec not(FilterSpec expression); FilterOperator getOperator(); void setOperator(FilterOperator operator); T getValue(); void setValue(Object value); List<FilterSpec> getExpression(); void setExpression(List<FilterSpec> expression); FilterSpec addExpression(FilterSpec expr); boolean hasExpressions(); @Override int hashCode(); @Override boolean equals(Object obj); @Override String toString(); FilterSpec normalize(); @Override FilterSpec clone(); @Override int compareTo(FilterSpec o); } | @Test public void testOrOneExpr() { FilterSpec spec1 = new FilterSpec(Arrays.asList("name1"), FilterOperator.EQ, "test"); FilterSpec orSpec = FilterSpec.or(spec1); Assert.assertSame(spec1, orSpec); } |
FilterSpec extends AbstractPathSpec implements Comparable<FilterSpec> { @Override public boolean equals(Object obj) { if (this == obj) { return true; } if (obj == null || getClass() != obj.getClass()) { return false; } FilterSpec other = (FilterSpec) obj; return CompareUtils.isEquals(path, other.path) && CompareUtils.isEquals(operator, other.operator) && CompareUtils.isEquals(value, other.value) && CompareUtils.isEquals(expressions, other.expressions); } protected FilterSpec(); FilterSpec(FilterSpec spec); FilterSpec(Object value); FilterSpec(FilterOperator operator, List<FilterSpec> expressions); FilterSpec(List<String> attributePath, FilterOperator operator, Object value); FilterSpec(PathSpec path, FilterOperator operator, Object value); private FilterSpec(PathSpec pathSpec, FilterOperator operator, Object value, List<FilterSpec> expressions); static FilterSpec and(Collection<FilterSpec> conditions); static FilterSpec and(FilterSpec... conditions); static FilterSpec or(Collection<FilterSpec> conditions); static FilterSpec or(FilterSpec... conditions); static FilterSpec not(FilterSpec expression); FilterOperator getOperator(); void setOperator(FilterOperator operator); T getValue(); void setValue(Object value); List<FilterSpec> getExpression(); void setExpression(List<FilterSpec> expression); FilterSpec addExpression(FilterSpec expr); boolean hasExpressions(); @Override int hashCode(); @Override boolean equals(Object obj); @Override String toString(); FilterSpec normalize(); @Override FilterSpec clone(); @Override int compareTo(FilterSpec o); } | @Test public void testEquals() { FilterSpec spec1A = new FilterSpec(Arrays.asList("name1"), FilterOperator.EQ, "test"); FilterSpec spec2A = new FilterSpec(Arrays.asList("name2"), FilterOperator.EQ, "test"); FilterSpec orSpecA = FilterSpec.or(spec1A, spec2A); FilterSpec spec1B = new FilterSpec(Arrays.asList("name1"), FilterOperator.EQ, "test"); FilterSpec spec2B = new FilterSpec(Arrays.asList("name2"), FilterOperator.EQ, "test"); FilterSpec orSpecB = FilterSpec.or(spec1B, spec2B); FilterSpec notSpec = FilterSpec.not(spec1A); Assert.assertEquals(orSpecA, orSpecB); Assert.assertEquals(spec1A, spec1A); Assert.assertEquals(spec1A, spec1B); Assert.assertEquals(spec2A, spec2B); Assert.assertEquals(orSpecA.hashCode(), orSpecB.hashCode()); Assert.assertEquals(spec1A.hashCode(), spec1B.hashCode()); Assert.assertEquals(spec2A.hashCode(), spec2B.hashCode()); Assert.assertNotEquals(spec1A, spec2B); Assert.assertNotEquals(spec1A, "somethingDifferent"); Assert.assertNotEquals(spec1A, null); Assert.assertNotEquals(spec2A, spec1B); Assert.assertNotEquals(orSpecA, spec1B); Assert.assertNotEquals(spec2B, orSpecA); Assert.assertNotEquals(spec2B, notSpec); Assert.assertEquals(notSpec, notSpec); Assert.assertEquals(orSpecB, orSpecB); Assert.assertNotEquals(notSpec, orSpecB); } |
FilterSpec extends AbstractPathSpec implements Comparable<FilterSpec> { public FilterSpec normalize() { List<FilterSpec> clonedExpressions = expressions != null ? cloneExpressions(expressions, true) : null; FilterSpec copy = new FilterSpec(path, operator, value, clonedExpressions); return copy; } protected FilterSpec(); FilterSpec(FilterSpec spec); FilterSpec(Object value); FilterSpec(FilterOperator operator, List<FilterSpec> expressions); FilterSpec(List<String> attributePath, FilterOperator operator, Object value); FilterSpec(PathSpec path, FilterOperator operator, Object value); private FilterSpec(PathSpec pathSpec, FilterOperator operator, Object value, List<FilterSpec> expressions); static FilterSpec and(Collection<FilterSpec> conditions); static FilterSpec and(FilterSpec... conditions); static FilterSpec or(Collection<FilterSpec> conditions); static FilterSpec or(FilterSpec... conditions); static FilterSpec not(FilterSpec expression); FilterOperator getOperator(); void setOperator(FilterOperator operator); T getValue(); void setValue(Object value); List<FilterSpec> getExpression(); void setExpression(List<FilterSpec> expression); FilterSpec addExpression(FilterSpec expr); boolean hasExpressions(); @Override int hashCode(); @Override boolean equals(Object obj); @Override String toString(); FilterSpec normalize(); @Override FilterSpec clone(); @Override int compareTo(FilterSpec o); } | @Test public void testNormalize() { FilterSpec spec1A = new FilterSpec(Arrays.asList("name1"), FilterOperator.EQ, "test"); FilterSpec spec2A = new FilterSpec(Arrays.asList("name2"), FilterOperator.EQ, "test"); FilterSpec orSpecA = FilterSpec.or(spec1A, spec2A); FilterSpec spec1B = new FilterSpec(Arrays.asList("name2"), FilterOperator.EQ, "test"); FilterSpec spec2B = new FilterSpec(Arrays.asList("name1"), FilterOperator.EQ, "test"); FilterSpec orSpecB = FilterSpec.or(spec1B, spec2B); Assert.assertNotEquals(orSpecA, orSpecB); Assert.assertEquals(orSpecA, orSpecA.normalize()); FilterSpec norm = orSpecB.normalize(); Assert.assertEquals(orSpecA, norm); } |
FilterOperator { public boolean matches(Object value1, Object value2){ throw new UnsupportedOperationException("not implemented"); } protected FilterOperator(String id); String name(); @Override int hashCode(); @Override boolean equals(Object obj); @Override String toString(); String getName(); boolean matches(Object value1, Object value2); Type getFilterType(QueryParameter queryParameter, Type attributeType); static final FilterOperator AND; static final FilterOperator SELECT; static final FilterOperator GROUP; static final FilterOperator LIKE; static final FilterOperator OR; static final FilterOperator NOT; static final FilterOperator EQ; static final FilterOperator LT; static final FilterOperator LE; static final FilterOperator GT; static final FilterOperator GE; static final FilterOperator NEQ; } | @Test(expected = UnsupportedOperationException.class) public void andMatchNotSupported() { FilterOperator.AND.matches(null, null); }
@Test(expected = UnsupportedOperationException.class) public void notMatchNotSupported() { FilterOperator.NOT.matches(null, null); }
@Test(expected = UnsupportedOperationException.class) public void orMatchNotSupported() { FilterOperator.OR.matches(null, null); }
@Test public void testLEOperator() { Assert.assertTrue(FilterOperator.LE.matches("a", "b")); }
@Test public void testLikeOperator() { Assert.assertTrue(FilterOperator.LIKE.matches("test", "te%")); Assert.assertTrue(FilterOperator.LIKE.matches("test", "Te%")); Assert.assertTrue(FilterOperator.LIKE.matches("test", "tE%")); Assert.assertFalse(FilterOperator.LIKE.matches("test", "aE%")); Assert.assertTrue(FilterOperator.LIKE.matches("test", "t%t")); Assert.assertTrue(FilterOperator.LIKE.matches("test.", "t%.")); Assert.assertFalse(FilterOperator.LIKE.matches(".", "t")); Assert.assertTrue(FilterOperator.LIKE.matches(".", ".")); Assert.assertFalse(FilterOperator.LIKE.matches(".", "t")); Assert.assertFalse(FilterOperator.LIKE.matches(".", "t")); Assert.assertFalse(FilterOperator.LIKE.matches("[", "t")); Assert.assertFalse(FilterOperator.LIKE.matches("\\", "t")); Assert.assertFalse(FilterOperator.LIKE.matches("^", "t")); Assert.assertFalse(FilterOperator.LIKE.matches("$", "t")); Assert.assertFalse(FilterOperator.LIKE.matches("|", "t")); Assert.assertFalse(FilterOperator.LIKE.matches("?", "t")); Assert.assertFalse(FilterOperator.LIKE.matches(")", "t")); Assert.assertFalse(FilterOperator.LIKE.matches("(", "t")); Assert.assertFalse(FilterOperator.LIKE.matches("+", "t")); Assert.assertFalse(FilterOperator.LIKE.matches("*", "t")); Assert.assertTrue(FilterOperator.LIKE.matches(".", ".")); Assert.assertTrue(FilterOperator.LIKE.matches("[", "[")); Assert.assertTrue(FilterOperator.LIKE.matches("\\", "\\")); Assert.assertTrue(FilterOperator.LIKE.matches("^", "^")); Assert.assertTrue(FilterOperator.LIKE.matches("$", "$")); Assert.assertTrue(FilterOperator.LIKE.matches("|", "|")); Assert.assertTrue(FilterOperator.LIKE.matches("?", "?")); Assert.assertTrue(FilterOperator.LIKE.matches(")", ")")); Assert.assertTrue(FilterOperator.LIKE.matches("(", "(")); Assert.assertTrue(FilterOperator.LIKE.matches("+", "+")); Assert.assertTrue(FilterOperator.LIKE.matches("*", "*")); Assert.assertFalse(FilterOperator.LIKE.matches(null, "*")); }
@Test(expected = BadRequestException.class) public void testLikeWithoutPattern() { FilterOperator.LIKE.matches("test", null); } |
FilterOperator { public Type getFilterType(QueryParameter queryParameter, Type attributeType) { return attributeType; } protected FilterOperator(String id); String name(); @Override int hashCode(); @Override boolean equals(Object obj); @Override String toString(); String getName(); boolean matches(Object value1, Object value2); Type getFilterType(QueryParameter queryParameter, Type attributeType); static final FilterOperator AND; static final FilterOperator SELECT; static final FilterOperator GROUP; static final FilterOperator LIKE; static final FilterOperator OR; static final FilterOperator NOT; static final FilterOperator EQ; static final FilterOperator LT; static final FilterOperator LE; static final FilterOperator GT; static final FilterOperator GE; static final FilterOperator NEQ; } | @Test public void testLikeOperatorUsesStringType() { Assert.assertEquals(String.class, FilterOperator.LIKE.getFilterType(null, Integer.class)); }
@Test public void testDefaultOperatorsUsesSameType() { Assert.assertEquals(Integer.class, FilterOperator.EQ.getFilterType(null, Integer.class)); Assert.assertEquals(Integer.class, FilterOperator.GT.getFilterType(null, Integer.class)); Assert.assertEquals(Integer.class, FilterOperator.GE.getFilterType(null, Integer.class)); Assert.assertEquals(Boolean.class, FilterOperator.LT.getFilterType(null, Boolean.class)); Assert.assertEquals(Long.class, FilterOperator.LE.getFilterType(null, Long.class)); } |
ConstraintViolationImpl implements ConstraintViolation<Object> { @SuppressWarnings({"rawtypes", "unchecked"}) @Override public Class getRootBeanClass() { return resourceClass; } private ConstraintViolationImpl(ResourceRegistry resourceRegistry, ErrorData errorData, QueryContext queryContext); static ConstraintViolationImpl fromError(ResourceRegistry resourceRegistry, ErrorData error, QueryContext queryContext); ErrorData getErrorData(); Serializable getResourceId(); @Override Object getRootBean(); @Override Object getLeafBean(); @Override Object getInvalidValue(); @Override Object[] getExecutableParameters(); @Override Object getExecutableReturnValue(); @Override String getMessage(); @Override ConstraintDescriptor<?> getConstraintDescriptor(); @Override String getMessageTemplate(); @Override Path getPropertyPath(); @SuppressWarnings({"rawtypes", "unchecked"}) @Override Class getRootBeanClass(); @Override U unwrap(Class<U> arg0); } | @Test public void getRootBeanClass() { Assert.assertEquals(Task.class, violation.getRootBeanClass()); } |
FilterOperator { @Override public boolean equals(Object obj) { if (obj != null && obj instanceof FilterOperator) { FilterOperator other = (FilterOperator) obj; return CompareUtils.isEquals(id, other.id); } return false; } protected FilterOperator(String id); String name(); @Override int hashCode(); @Override boolean equals(Object obj); @Override String toString(); String getName(); boolean matches(Object value1, Object value2); Type getFilterType(QueryParameter queryParameter, Type attributeType); static final FilterOperator AND; static final FilterOperator SELECT; static final FilterOperator GROUP; static final FilterOperator LIKE; static final FilterOperator OR; static final FilterOperator NOT; static final FilterOperator EQ; static final FilterOperator LT; static final FilterOperator LE; static final FilterOperator GT; static final FilterOperator GE; static final FilterOperator NEQ; } | @Test public void testEquals() { Assert.assertEquals(FilterOperator.AND, FilterOperator.AND); Assert.assertNotEquals(FilterOperator.AND, "notAnOperator"); Assert.assertNotEquals(FilterOperator.AND, null); Assert.assertEquals(FilterOperator.OR, FilterOperator.OR); Assert.assertEquals(FilterOperator.OR, new FilterOperator("OR") { @Override public boolean matches(Object value1, Object value2) { return false; } }); Assert.assertNotEquals(FilterOperator.AND, FilterOperator.OR); } |
PagingSpecUrlBuilder { public String build(QueryAdapter queryAdapter) { QueryContext queryContext = queryAdapter.getQueryContext(); UrlBuilder urlBuilder = moduleRegistry.getUrlBuilder(); Object relationshipSourceId = requestSpec.getId(); ResourceField relationshipField = requestSpec.getRelationshipField(); ResourceInformation rootInfo; if (relationshipField == null) { rootInfo = queryAdapter.getResourceInformation(); } else { rootInfo = relationshipField.getResourceInformation(); } return urlBuilder.buildUrl(queryContext, rootInfo, relationshipSourceId, queryAdapter.toQuerySpec(), relationshipField != null ? relationshipField.getJsonName() : null, queryAdapter.isSelfLink()); } PagingSpecUrlBuilder(final ModuleRegistry moduleRegistry, final RepositoryRequestSpec requestSpec); String build(QueryAdapter queryAdapter); } | @Test public void testSelfLink() { QueryContext queryContext = new QueryContext(); queryContext.setBaseUrl("http: queryContext.setRequestPath("/relationships/self"); QuerySpecAdapter adapter = new QuerySpecAdapter(new QuerySpec(Task.class), resourceRegistry, queryContext); PagingSpecUrlBuilder urlBuilder = new PagingSpecUrlBuilder(moduleRegistry, repositoryRequestSpec); Assert.assertEquals("tasks/relationships/any", urlBuilder.build(adapter)); }
@Test public void testRelatedLink() { QueryContext queryContext = new QueryContext(); queryContext.setBaseUrl("http: queryContext.setRequestPath("/related"); QuerySpecAdapter adapter = new QuerySpecAdapter(new QuerySpec(Task.class), resourceRegistry, queryContext); PagingSpecUrlBuilder urlBuilder = new PagingSpecUrlBuilder(moduleRegistry, repositoryRequestSpec); Assert.assertEquals("tasks/any", urlBuilder.build(adapter)); } |
NumberSizePagingBehavior extends PagingBehaviorBase<NumberSizePagingSpec> { @Override public Map<String, Set<String>> serialize(final NumberSizePagingSpec pagingSpec, final String resourceType) { Map<String, Set<String>> values = new HashMap<>(); if (pagingSpec.getSize() != null || pagingSpec.getNumber() != 1) { values.put(String.format("page[%s]", NUMBER_PARAMETER), new HashSet<>(Arrays.asList(Long.toString(pagingSpec.getNumber())))); } if (pagingSpec.getSize() != null) { values.put(String.format("page[%s]", SIZE_PARAMETER), new HashSet<>(Arrays.asList(Long.toString(pagingSpec.getSize())))); } return values; } NumberSizePagingBehavior(); @Override boolean supports(Class<? extends PagingSpec> pagingSpecType); @Override Map<String, Set<String>> serialize(final NumberSizePagingSpec pagingSpec, final String resourceType); @Override NumberSizePagingSpec deserialize(final Map<String, Set<String>> parameters); @Override NumberSizePagingSpec createEmptyPagingSpec(); @Override NumberSizePagingSpec createDefaultPagingSpec(); @Override void build(final PagedLinksInformation linksInformation,
final ResourceList<?> resources,
final QueryAdapter queryAdapter,
final PagingSpecUrlBuilder urlBuilder); @Override boolean isRequired(final NumberSizePagingSpec pagingSpec); void setDefaultNumber(int defaultNumber); static Module createModule(); } | @Test public void testSerializeDefault() { NumberSizePagingBehavior pagingBehavior = new NumberSizePagingBehavior(); Map<String, Set<String>> result = pagingBehavior.serialize(new NumberSizePagingSpec(), "tasks"); assertFalse(result.containsKey("page[number]")); assertFalse(result.containsKey("page[size]")); assertEquals(0, result.size()); }
@Test public void testSerializeOffset() { NumberSizePagingBehavior pagingBehavior = new NumberSizePagingBehavior(); Map<String, Set<String>> result = pagingBehavior.serialize(new NumberSizePagingSpec(2, null), "tasks"); assertEquals(ImmutableSet.of("2"), result.get("page[number]")); assertFalse(result.containsKey("page[size]")); assertEquals(1, result.size()); }
@Test public void testSerializeLimit() { NumberSizePagingBehavior pagingBehavior = new NumberSizePagingBehavior(); Map<String, Set<String>> result = pagingBehavior.serialize(new NumberSizePagingSpec(1, 30), "tasks"); assertTrue(result.containsKey("page[number]")); assertEquals(ImmutableSet.of("30"), result.get("page[size]")); assertEquals(2, result.size()); }
@Test public void testSerialize() { NumberSizePagingBehavior pagingBehavior = new NumberSizePagingBehavior(); Map<String, Set<String>> result = pagingBehavior.serialize(new NumberSizePagingSpec(1, 30), "tasks"); assertEquals(ImmutableSet.of("1"), result.get("page[number]")); assertEquals(ImmutableSet.of("30"), result.get("page[size]")); assertEquals(2, result.size()); } |
NumberSizePagingBehavior extends PagingBehaviorBase<NumberSizePagingSpec> { @Override public NumberSizePagingSpec deserialize(final Map<String, Set<String>> parameters) { NumberSizePagingSpec result = createDefaultPagingSpec(); for (Map.Entry<String, Set<String>> param : parameters.entrySet()) { if (NUMBER_PARAMETER.equalsIgnoreCase(param.getKey())) { result.setNumber(getValue(param.getKey(), param.getValue()).intValue()); } else if (SIZE_PARAMETER.equalsIgnoreCase(param.getKey())) { Long size = getValue(param.getKey(), param.getValue()); if (maxPageLimit != null && size != null && size > maxPageLimit) { throw new BadRequestException( String.format("%s value %d is larger than the maximum allowed of %d", SIZE_PARAMETER, size, maxPageLimit) ); } result.setSize(size.intValue()); } else { throw new ParametersDeserializationException(param.getKey()); } } return result; } NumberSizePagingBehavior(); @Override boolean supports(Class<? extends PagingSpec> pagingSpecType); @Override Map<String, Set<String>> serialize(final NumberSizePagingSpec pagingSpec, final String resourceType); @Override NumberSizePagingSpec deserialize(final Map<String, Set<String>> parameters); @Override NumberSizePagingSpec createEmptyPagingSpec(); @Override NumberSizePagingSpec createDefaultPagingSpec(); @Override void build(final PagedLinksInformation linksInformation,
final ResourceList<?> resources,
final QueryAdapter queryAdapter,
final PagingSpecUrlBuilder urlBuilder); @Override boolean isRequired(final NumberSizePagingSpec pagingSpec); void setDefaultNumber(int defaultNumber); static Module createModule(); } | @Test public void testDeserializeDefaultWithNoParameters() { NumberSizePagingBehavior pagingBehavior = new NumberSizePagingBehavior(); NumberSizePagingSpec result = pagingBehavior.deserialize(Collections.emptyMap()); assertEquals(new NumberSizePagingSpec(1, null), result); }
@Test public void testDeserializeDefaultWithOffset() { NumberSizePagingBehavior pagingBehavior = new NumberSizePagingBehavior(); NumberSizePagingSpec result = pagingBehavior.deserialize(ImmutableMap.of("number", ImmutableSet.of("2"))); assertEquals(new NumberSizePagingSpec(2, null), result); }
@Test public void testDeserializeDefaultWithLimit() { NumberSizePagingBehavior pagingBehavior = new NumberSizePagingBehavior(); NumberSizePagingSpec result = pagingBehavior.deserialize(ImmutableMap.of("size", ImmutableSet.of("30"))); assertEquals(new NumberSizePagingSpec(1, 30), result); }
@Test public void testDeserializeLimitWithNoParameters() { NumberSizePagingBehavior pagingBehavior = new NumberSizePagingBehavior(); pagingBehavior.setDefaultLimit(30L); NumberSizePagingSpec result = pagingBehavior.deserialize(Collections.emptyMap()); assertEquals(new NumberSizePagingSpec(1, 30), result); }
@Test public void testDeserializeLimitWithOffset() { NumberSizePagingBehavior pagingBehavior = new NumberSizePagingBehavior(); pagingBehavior.setDefaultLimit(30L); NumberSizePagingSpec result = pagingBehavior.deserialize(ImmutableMap.of("number", ImmutableSet.of("1"))); assertEquals(new NumberSizePagingSpec(1, 30), result); }
@Test public void testDeserializeLimitWithLimit() { NumberSizePagingBehavior pagingBehavior = new NumberSizePagingBehavior(); pagingBehavior.setDefaultLimit(30L); NumberSizePagingSpec result = pagingBehavior.deserialize(ImmutableMap.of("size", ImmutableSet.of("10"))); assertEquals(new NumberSizePagingSpec(1, 10), result); }
@Test public void testDeserialize() { NumberSizePagingBehavior pagingBehavior = new NumberSizePagingBehavior(); NumberSizePagingSpec result = pagingBehavior.deserialize(ImmutableMap.of("number", ImmutableSet.of("2"), "size", ImmutableSet.of("30"))); assertEquals(new NumberSizePagingSpec(2, 30), result); } |
ConstraintViolationImpl implements ConstraintViolation<Object> { @Override public Object getRootBean() { throw new UnsupportedOperationException(); } private ConstraintViolationImpl(ResourceRegistry resourceRegistry, ErrorData errorData, QueryContext queryContext); static ConstraintViolationImpl fromError(ResourceRegistry resourceRegistry, ErrorData error, QueryContext queryContext); ErrorData getErrorData(); Serializable getResourceId(); @Override Object getRootBean(); @Override Object getLeafBean(); @Override Object getInvalidValue(); @Override Object[] getExecutableParameters(); @Override Object getExecutableReturnValue(); @Override String getMessage(); @Override ConstraintDescriptor<?> getConstraintDescriptor(); @Override String getMessageTemplate(); @Override Path getPropertyPath(); @SuppressWarnings({"rawtypes", "unchecked"}) @Override Class getRootBeanClass(); @Override U unwrap(Class<U> arg0); } | @Test(expected = UnsupportedOperationException.class) public void getRootBean() { violation.getRootBean(); } |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.