Datasets:

Minata
/

512src_fm_fc_ms_ff_method2testcases_v0

Dataset card Data Studio Files Files and versions Community

Split (2)

train · 184k rows

method2testcases stringlengths 118 3.08k
### Question: HomeModuleExtension implements ModuleExtension { public void addPath(String path) { paths.add(path); } @Override Class<? extends Module> getTargetModule(); @Override boolean isOptional(); void addPath(String path); }### Answer: @Test public void test() { HomeModuleExtension extension = new HomeModuleExtension(); extension.addPath("/test/directory/"); extension.addPath("/test/something"); SimpleModule extensionModule = new SimpleModule("extension"); extensionModule.addExtension(extension); HomeModule module = Mockito.spy(HomeModule.create(HomeFormat.JSON_HOME)); CrnkBoot boot = new CrnkBoot(); boot.addModule(module); boot.addModule(extensionModule); boot.setServiceUrlProvider(new ConstantServiceUrlProvider("http: boot.boot(); List<String> list = module.list("/", new QueryContext()); Assert.assertTrue(list.toString(), list.contains("test/")); list = module.list("/test/", new QueryContext()); Assert.assertTrue(list.toString(), list.contains("directory/")); Assert.assertTrue(list.toString(), list.contains("something")); }
### Question: HomeModule implements Module, ModuleExtensionAware<HomeModuleExtension> { protected HttpRequestProcessor getRequestProcessor() { return requestProcessor; } protected HomeModule(); static HomeModule create(); static HomeModule create(HomeFormat defaultFormat); void addPathFilter(Predicate<HttpRequestContext> pathFilter); @Override String getModuleName(); @Override void setupModule(final ModuleContext context); List<String> list(String requestPath, QueryContext queryContext); boolean hasPotentialFilterIssues(); @Override void setExtensions(List<HomeModuleExtension> extensions); @Override void init(); static final String JSON_HOME_CONTENT_TYPE; static final String JSON_CONTENT_TYPE; }### Answer: @Test public void checkAccepts() { HttpRequestContextBase context = Mockito.mock(HttpRequestContextBase.class); Mockito.when(context.getMethod()).thenReturn("GET"); Mockito.when(context.getRequestHeader(Mockito.eq(HttpHeaders.HTTP_HEADER_ACCEPT))).thenReturn(HttpHeaders.JSON_CONTENT_TYPE); HttpRequestProcessor requestProcessor = module.getRequestProcessor(); HttpRequestContextBaseAdapter contextAdapter = new HttpRequestContextBaseAdapter(context); Mockito.when(context.getPath()).thenReturn("/"); Assert.assertTrue(requestProcessor.accepts(contextAdapter)); Mockito.when(context.getPath()).thenReturn("/doesNotExists"); Assert.assertFalse(requestProcessor.accepts(contextAdapter)); Mockito.when(context.getPath()).thenReturn("/tasks"); Assert.assertFalse(requestProcessor.accepts(contextAdapter)); }
### Question: DocumentMapperUtil { public ResourceIdentifier toResourceId(Object entity) { if (entity == null) { return null; } RegistryEntry entry = resourceRegistry.findEntry(entity); ResourceInformation resourceInformation = entry.getResourceInformation(); return resourceInformation.toResourceIdentifier(entity); } DocumentMapperUtil(ResourceRegistry resourceRegistry, ObjectMapper objectMapper, PropertiesProvider propertiesProvider, UrlBuilder urlBuilder); @SuppressWarnings({ "unchecked", "rawtypes" }) static List<T> toList(Object entity); Link getRelationshipLink(Resource resource, ResourceField field, boolean related); List<ResourceIdentifier> toResourceIds(Collection<?> entities); ResourceIdentifier toResourceId(Object entity); void setLinks(LinksContainer container, LinksInformation linksInformation, QueryAdapter queryAdapter); void setMeta(MetaContainer container, MetaInformation metaInformation); ResourceInformation getResourceInformation(Object resource); ResourceInformation getResourceInformation(String resourceType); boolean hasResourceInformation(String resourceType); String getSelfUrl(QueryContext queryContext, ResourceInformation resourceInformation, Object entity); static SerializerUtil getSerializerUtil(); }### Answer: @Test public void toResourceId() { Task task = new Task(); task.setId(12L); ResourceIdentifier id = util.toResourceId(task); Assert.assertEquals("tasks", id.getType()); Assert.assertEquals("12", id.getId()); } @Test public void nullRoResourceId() { Assert.assertNull(util.toResourceId(null)); }
### Question: DocumentMapperUtil { public List<ResourceIdentifier> toResourceIds(Collection<?> entities) { List<ResourceIdentifier> results = new ArrayList<>(); for (Object entity : entities) { results.add(toResourceId(entity)); } return results; } DocumentMapperUtil(ResourceRegistry resourceRegistry, ObjectMapper objectMapper, PropertiesProvider propertiesProvider, UrlBuilder urlBuilder); @SuppressWarnings({ "unchecked", "rawtypes" }) static List<T> toList(Object entity); Link getRelationshipLink(Resource resource, ResourceField field, boolean related); List<ResourceIdentifier> toResourceIds(Collection<?> entities); ResourceIdentifier toResourceId(Object entity); void setLinks(LinksContainer container, LinksInformation linksInformation, QueryAdapter queryAdapter); void setMeta(MetaContainer container, MetaInformation metaInformation); ResourceInformation getResourceInformation(Object resource); ResourceInformation getResourceInformation(String resourceType); boolean hasResourceInformation(String resourceType); String getSelfUrl(QueryContext queryContext, ResourceInformation resourceInformation, Object entity); static SerializerUtil getSerializerUtil(); }### Answer: @Test public void toResourceIds() { Task task = new Task(); task.setId(12L); List<ResourceIdentifier> ids = util.toResourceIds(Arrays.asList(task)); ResourceIdentifier id = ids.get(0); Assert.assertEquals("tasks", id.getType()); Assert.assertEquals("12", id.getId()); }
### Question: DefaultInformationBuilder implements InformationBuilder { @Override public RelationshipRepositoryInformationBuilder createRelationshipRepository(String sourceResourceType, String targetResourceType) { RelationshipMatcher matcher = new RelationshipMatcher(); matcher.rule().target(targetResourceType).source(sourceResourceType).add(); return createRelationshipRepository(matcher); } DefaultInformationBuilder(TypeParser typeParser); @Override FieldInformationBuilder createResourceField(); @Override RelationshipRepositoryInformationBuilder createRelationshipRepository(String sourceResourceType, String targetResourceType); @Override RelationshipRepositoryInformationBuilder createRelationshipRepository(RelationshipMatcher matcher); @Override ResourceRepositoryInformationBuilder createResourceRepository(); @Override ResourceInformationBuilder createResource(Class<?> resourceClass, String resourceType); @Override ResourceInformationBuilder createResource(Class<?> resourceClass, String resourceType, String resourcePath); }### Answer: @Test public void checkRelationshipRepository() { InformationBuilder.RelationshipRepositoryInformationBuilder repositoryBuilder = builder.createRelationshipRepository("projects", "tasks"); RepositoryMethodAccess expectedAccess = new RepositoryMethodAccess(true, false, true, false); repositoryBuilder.setAccess(expectedAccess); RelationshipRepositoryInformation repositoryInformation = repositoryBuilder.build(); RepositoryMethodAccess actualAccess = repositoryInformation.getAccess(); Assert.assertEquals(expectedAccess, actualAccess); }
### Question: HomeModule implements Module, ModuleExtensionAware<HomeModuleExtension> { @Override public String getModuleName() { return "home"; } protected HomeModule(); static HomeModule create(); static HomeModule create(HomeFormat defaultFormat); void addPathFilter(Predicate<HttpRequestContext> pathFilter); @Override String getModuleName(); @Override void setupModule(final ModuleContext context); List<String> list(String requestPath, QueryContext queryContext); boolean hasPotentialFilterIssues(); @Override void setExtensions(List<HomeModuleExtension> extensions); @Override void init(); static final String JSON_HOME_CONTENT_TYPE; static final String JSON_CONTENT_TYPE; }### Answer: @Test public void moduleName() { HomeModule module = boot.getModuleRegistry().getModule(HomeModule.class).get(); Assert.assertEquals("home", module.getModuleName()); }
### Question: RepositoryAdapterUtils { public static LinksInformation enrichLinksInformation(ModuleRegistry moduleRegistry, LinksInformation linksInformation, Object resource, RepositoryRequestSpec requestSpec) { if (requestSpec.getQueryAdapter() instanceof QuerySpecAdapter && resource instanceof ResourceList) { ResourceList<?> resources = (ResourceList<?>) resource; linksInformation = enrichPageLinksInformation(moduleRegistry, linksInformation, resources, requestSpec); } return linksInformation; } static LinksInformation enrichLinksInformation(ModuleRegistry moduleRegistry, LinksInformation linksInformation, Object resource, RepositoryRequestSpec requestSpec); }### Answer: @Test public void enrichSelfLinksInformationNoQuerySpec() { ResourceList resources = new DefaultResourceList(); when(requestSpec.getQueryAdapter()).thenReturn(mock(QueryAdapter.class)); LinksInformation result = RepositoryAdapterUtils.enrichLinksInformation(moduleRegistry, null, resources, requestSpec); assertThat(result, is(nullValue())); }
### Question: StringUtils { public static String join(String delimiter, Iterable<?> stringsIterable) { List<String> strings = new LinkedList<>(); Iterator<?> iterator = stringsIterable.iterator(); while (iterator.hasNext()) { Object obj = iterator.next(); if (obj == null) { strings.add(null); } else { strings.add(obj.toString()); } } StringBuilder ab = new StringBuilder(); for (int i = 0; i < strings.size(); i++) { ab.append(strings.get(i)); if (i != strings.size() - 1) { ab.append(delimiter); } } return ab.toString(); } private StringUtils(); static String join(String delimiter, Iterable<?> stringsIterable); static boolean isBlank(String value); static String emptyToNull(String value); static String decapitalize(String name); static String firstToUpper(String name); static String nullToEmpty(String value); static final String EMPTY; }### Answer: @Test public void onSingleElementShouldReturnTheSameValue() { String string = "hello world"; List<String> values = Collections.singletonList(string); String result = StringUtils.join(",", values); assertThat(result).isEqualTo(string); } @Test public void onTwoElementsShouldReturnJoinedValues() { List<String> values = Arrays.asList("hello", "world"); String result = StringUtils.join(" ", values); assertThat(result).isEqualTo("hello world"); } @Test public void onJoinOfNulls() { Assert.assertEquals("null,null", StringUtils.join(",", Arrays.asList(null, null))); }
### Question: StringUtils { public static boolean isBlank(String value) { int strLen; if (value == null \|\| (strLen = value.length()) == 0) { return true; } for (int i = 0; i < strLen; i++) { if ((!Character.isWhitespace(value.charAt(i)))) { return false; } } return true; } private StringUtils(); static String join(String delimiter, Iterable<?> stringsIterable); static boolean isBlank(String value); static String emptyToNull(String value); static String decapitalize(String name); static String firstToUpper(String name); static String nullToEmpty(String value); static final String EMPTY; }### Answer: @Test public void onIsBlankValues() { assertTrue(StringUtils.isBlank(null)); assertTrue(StringUtils.isBlank("")); assertTrue(StringUtils.isBlank(" ")); assertFalse(StringUtils.isBlank("crnk")); assertFalse(StringUtils.isBlank(" crnk ")); }
### Question: StringUtils { public static String decapitalize(String name) { if (name == null \|\| name.length() == 0) { return name; } char[] chars = name.toCharArray(); chars[0] = Character.toLowerCase(chars[0]); return new String(chars); } private StringUtils(); static String join(String delimiter, Iterable<?> stringsIterable); static boolean isBlank(String value); static String emptyToNull(String value); static String decapitalize(String name); static String firstToUpper(String name); static String nullToEmpty(String value); static final String EMPTY; }### Answer: @Test public void checkDecapitalize() { Assert.assertEquals("", StringUtils.decapitalize("")); Assert.assertEquals("test", StringUtils.decapitalize("Test")); Assert.assertEquals("someTest", StringUtils.decapitalize("SomeTest")); }
### Question: PropertyUtils { public static Class<?> getPropertyClass(Class<?> beanClass, String field) { return INSTANCE.findPropertyClass(beanClass, field); } private PropertyUtils(); static Object getProperty(Object bean, String field); static Class<?> getPropertyClass(Class<?> beanClass, String field); static Type getPropertyType(Class<?> beanClass, String field); static Object getProperty(Object bean, List<String> propertyPath); static Class<?> getPropertyClass(Class<?> clazz, List<String> propertyPath); static void setProperty(Object bean, String field, Object value); @SuppressWarnings("unchecked") static Object prepareValue(Object value, Class<?> fieldClass); }### Answer: @Test public void getPropertyClassForMethodPropertyShouldReturnClass() { Object result = PropertyUtils.getPropertyClass(Bean.class, "methodProperty"); assertThat(result).isEqualTo(String.class); } @Test public void onStringPublicReturnStringClass() { Object result = PropertyUtils.getPropertyClass(Bean.class, "publicProperty"); assertThat(result).isEqualTo(String.class); } @Test public void getPropertyClassShouldThrowExceptionForInvalidField() { try { PropertyUtils.getPropertyClass(Bean.class, "doesNotExist"); Assert.fail(); } catch (PropertyException e) { Assert.assertEquals("doesNotExist", e.getField()); Assert.assertEquals(Bean.class, e.getResourceClass()); } } @Test public void onBooleanPropertyWithMutatorsReturnBooleanClass() { Object result = PropertyUtils.getPropertyClass(Bean.class, "booleanPropertyWithMutators"); assertThat(result).isEqualTo(Boolean.class); } @Test public void unknownPropertyClassThrowingException() { expectedException.expect(PropertyException.class); PropertyUtils.getPropertyClass(Bean.class, "attrThatDoesNotExist"); }
### Question: PropertyUtils { public static Type getPropertyType(Class<?> beanClass, String field) { return INSTANCE.findPropertyType(beanClass, field); } private PropertyUtils(); static Object getProperty(Object bean, String field); static Class<?> getPropertyClass(Class<?> beanClass, String field); static Type getPropertyType(Class<?> beanClass, String field); static Object getProperty(Object bean, List<String> propertyPath); static Class<?> getPropertyClass(Class<?> clazz, List<String> propertyPath); static void setProperty(Object bean, String field, Object value); @SuppressWarnings("unchecked") static Object prepareValue(Object value, Class<?> fieldClass); }### Answer: @Test public void getPropertyTypeForMethodPropertyShouldReturnType() { Object result = PropertyUtils.getPropertyType(Bean.class, "methodProperty"); assertThat(result).isEqualTo(String.class); } @Test public void getPropertyTypeForSetShouldReturnGenericType() { Object result = PropertyUtils.getPropertyType(Bean.class, "setProperty"); assertThat(ParameterizedType.class).isAssignableFrom(result.getClass()); } @Test public void getPropertyTypeShouldThrowExceptionForInvalidField() { try { PropertyUtils.getPropertyType(Bean.class, "doesNotExist"); Assert.fail(); } catch (PropertyException e) { Assert.assertEquals("doesNotExist", e.getField()); Assert.assertEquals(Bean.class, e.getResourceClass()); } } @Test public void onStringPublicReturnStringType() { Object result = PropertyUtils.getPropertyType(Bean.class, "publicProperty"); assertThat(result).isEqualTo(String.class); } @Test public void unknownPropertyTypeThrowingException() { expectedException.expect(PropertyException.class); PropertyUtils.getPropertyType(Bean.class, "attrThatDoesNotExist"); }
### Question: ClientResourceUpsert extends ResourceUpsert { public String getUID(ResourceIdentifier id) { return id.getType() + "#" + id.getId(); } ClientResourceUpsert(ClientProxyFactory proxyFactory); String getUID(ResourceIdentifier id); String getUID(RegistryEntry entry, Serializable id); void setRelations(List<Resource> resources, QueryContext queryContext); List<Object> allocateResources(List<Resource> resources, QueryContext queryContext); @Override boolean isAcceptable(JsonPath jsonPath, String method); @Override Result<Response> handleAsync(JsonPath jsonPath, QueryAdapter queryAdapter, Document requestDocument); }### Answer: @Test public void testUIDComputation() { Serializable id = "test"; RegistryEntry entry = Mockito.mock(RegistryEntry.class); ResourceInformation resourceInformation = Mockito.mock(ResourceInformation.class); Mockito.when(resourceInformation.getResourceType()).thenReturn("someType"); Mockito.when(resourceInformation.toIdString(Mockito.eq(id))).thenReturn("someId"); Mockito.when(entry.getResourceInformation()).thenReturn(resourceInformation); String uid = upsert.getUID(entry, id); Assert.assertEquals("someType#someId", uid); }
### Question: ClientResourceUpsert extends ResourceUpsert { @Override public boolean isAcceptable(JsonPath jsonPath, String method) { throw new UnsupportedOperationException(); } ClientResourceUpsert(ClientProxyFactory proxyFactory); String getUID(ResourceIdentifier id); String getUID(RegistryEntry entry, Serializable id); void setRelations(List<Resource> resources, QueryContext queryContext); List<Object> allocateResources(List<Resource> resources, QueryContext queryContext); @Override boolean isAcceptable(JsonPath jsonPath, String method); @Override Result<Response> handleAsync(JsonPath jsonPath, QueryAdapter queryAdapter, Document requestDocument); }### Answer: @Test(expected = UnsupportedOperationException.class) public void testAcceptableNotSupported() { upsert.isAcceptable(null, null); }
### Question: ClientResourceUpsert extends ResourceUpsert { @Override protected HttpMethod getHttpMethod() { throw new UnsupportedOperationException(); } ClientResourceUpsert(ClientProxyFactory proxyFactory); String getUID(ResourceIdentifier id); String getUID(RegistryEntry entry, Serializable id); void setRelations(List<Resource> resources, QueryContext queryContext); List<Object> allocateResources(List<Resource> resources, QueryContext queryContext); @Override boolean isAcceptable(JsonPath jsonPath, String method); @Override Result<Response> handleAsync(JsonPath jsonPath, QueryAdapter queryAdapter, Document requestDocument); }### Answer: @Test(expected = UnsupportedOperationException.class) public void testMethodNotSupported() { upsert.getHttpMethod(); }
### Question: ClassUtils { public static boolean existsClass(String className) { try { ClassLoader classLoader = Thread.currentThread().getContextClassLoader(); loadClass(classLoader, className); return true; } catch (IllegalStateException e) { return false; } } private ClassUtils(); static boolean existsClass(String className); static Class<?> loadClass(ClassLoader classLoader, String className); static List<Field> getClassFields(Class<?> beanClass); static Optional<T> getAnnotation(Class<?> beanClass, Class<T> annotationClass); static Field findClassField(Class<?> beanClass, String fieldName); static Method findGetter(Class<?> beanClass, String fieldName); static String getGetterFieldName(Method getter); static Method findSetter(Class<?> beanClass, String fieldName, Class<?> fieldType); static List<Method> getClassGetters(Class<?> beanClass); static List<Method> getClassSetters(Class<?> beanClass); static Method findMethodWith(Class<?> searchClass, Class<? extends Annotation> annotationClass); static T newInstance(Class<T> clazz); static boolean isBooleanGetter(Method method); static Class<?> getRawType(Type type); static boolean isPrimitiveType(Class<?> type); static Type getElementType(Type genericType); static final String PREFIX_GETTER_IS; static final String PREFIX_GETTER_GET; }### Answer: @Test public void stringMustExist() { Assert.assertTrue(ClassUtils.existsClass(String.class.getName())); } @Test public void unknownClassMustNotExist() { Assert.assertFalse(ClassUtils.existsClass("does.not.exist")); }
### Question: ClassUtils { public static Class<?> getRawType(Type type) { if (type instanceof Class) { return (Class<?>) type; } else if (type instanceof ParameterizedType) { return getRawType(((ParameterizedType) type).getRawType()); } else if (type instanceof TypeVariable<?>) { return getRawType(((TypeVariable<?>) type).getBounds()[0]); } else if (type instanceof WildcardType) { return getRawType(((WildcardType) type).getUpperBounds()[0]); } throw new IllegalStateException("unknown type: " + type); } private ClassUtils(); static boolean existsClass(String className); static Class<?> loadClass(ClassLoader classLoader, String className); static List<Field> getClassFields(Class<?> beanClass); static Optional<T> getAnnotation(Class<?> beanClass, Class<T> annotationClass); static Field findClassField(Class<?> beanClass, String fieldName); static Method findGetter(Class<?> beanClass, String fieldName); static String getGetterFieldName(Method getter); static Method findSetter(Class<?> beanClass, String fieldName, Class<?> fieldType); static List<Method> getClassGetters(Class<?> beanClass); static List<Method> getClassSetters(Class<?> beanClass); static Method findMethodWith(Class<?> searchClass, Class<? extends Annotation> annotationClass); static T newInstance(Class<T> clazz); static boolean isBooleanGetter(Method method); static Class<?> getRawType(Type type); static boolean isPrimitiveType(Class<?> type); static Type getElementType(Type genericType); static final String PREFIX_GETTER_IS; static final String PREFIX_GETTER_GET; }### Answer: @Test public void rawTypeFromParameterizedType() { Class<?> result = ClassUtils.getRawType(ProjectRepository.class.getGenericSuperclass()); assertThat(result).isEqualTo(ResourceRepositoryBase.class); } @Test public void rawTypeFromRawType() { Class<?> result = ClassUtils.getRawType(String.class); assertThat(result).isEqualTo(String.class); } @Test(expected = IllegalStateException.class) public void exceptionForUnknownRawType() { ClassUtils.getRawType(null); }
### Question: ClassUtils { public static List<Field> getClassFields(Class<?> beanClass) { Map<String, Field> resultMap = new HashMap<>(); LinkedList<Field> results = new LinkedList<>(); Class<?> currentClass = beanClass; while (currentClass != null && currentClass != Object.class) { for (Field field : currentClass.getDeclaredFields()) { if (!field.isSynthetic()) { Field v = resultMap.get(field.getName()); if (v == null) { resultMap.put(field.getName(), field); results.add(field); } } } currentClass = currentClass.getSuperclass(); } return results; } private ClassUtils(); static boolean existsClass(String className); static Class<?> loadClass(ClassLoader classLoader, String className); static List<Field> getClassFields(Class<?> beanClass); static Optional<T> getAnnotation(Class<?> beanClass, Class<T> annotationClass); static Field findClassField(Class<?> beanClass, String fieldName); static Method findGetter(Class<?> beanClass, String fieldName); static String getGetterFieldName(Method getter); static Method findSetter(Class<?> beanClass, String fieldName, Class<?> fieldType); static List<Method> getClassGetters(Class<?> beanClass); static List<Method> getClassSetters(Class<?> beanClass); static Method findMethodWith(Class<?> searchClass, Class<? extends Annotation> annotationClass); static T newInstance(Class<T> clazz); static boolean isBooleanGetter(Method method); static Class<?> getRawType(Type type); static boolean isPrimitiveType(Class<?> type); static Type getElementType(Type genericType); static final String PREFIX_GETTER_IS; static final String PREFIX_GETTER_GET; }### Answer: @Test public void onClassInheritanceShouldReturnInheritedClasses() { List<Field> result = ClassUtils.getClassFields(ChildClass.class); assertThat(result).hasSize(2); }
### Question: ClassUtils { public static Field findClassField(Class<?> beanClass, String fieldName) { Class<?> currentClass = beanClass; while (currentClass != null && currentClass != Object.class) { for (Field field : currentClass.getDeclaredFields()) { if (field.isSynthetic()) { continue; } if (field.getName().equals(fieldName)) { return field; } } currentClass = currentClass.getSuperclass(); } return null; } private ClassUtils(); static boolean existsClass(String className); static Class<?> loadClass(ClassLoader classLoader, String className); static List<Field> getClassFields(Class<?> beanClass); static Optional<T> getAnnotation(Class<?> beanClass, Class<T> annotationClass); static Field findClassField(Class<?> beanClass, String fieldName); static Method findGetter(Class<?> beanClass, String fieldName); static String getGetterFieldName(Method getter); static Method findSetter(Class<?> beanClass, String fieldName, Class<?> fieldType); static List<Method> getClassGetters(Class<?> beanClass); static List<Method> getClassSetters(Class<?> beanClass); static Method findMethodWith(Class<?> searchClass, Class<? extends Annotation> annotationClass); static T newInstance(Class<T> clazz); static boolean isBooleanGetter(Method method); static Class<?> getRawType(Type type); static boolean isPrimitiveType(Class<?> type); static Type getElementType(Type genericType); static final String PREFIX_GETTER_IS; static final String PREFIX_GETTER_GET; }### Answer: @Test public void onClassInheritanceShouldReturnInheritedField() { Field result = ClassUtils.findClassField(ChildClass.class, "parentField"); assertThat(result).isNotNull(); assertThat(result.getName()).isEqualTo("parentField"); assertThat(result.getDeclaringClass()).isEqualTo(ParentClass.class); }
### Question: ClassUtils { public static List<Method> getClassSetters(Class<?> beanClass) { Map<String, Method> result = new HashMap<>(); Class<?> currentClass = beanClass; while (currentClass != null && currentClass != Object.class) { for (Method method : currentClass.getDeclaredMethods()) { if (!method.isSynthetic() && isSetter(method)) { result.putIfAbsent(method.getName(), method); } } currentClass = currentClass.getSuperclass(); } return new LinkedList<>(result.values()); } private ClassUtils(); static boolean existsClass(String className); static Class<?> loadClass(ClassLoader classLoader, String className); static List<Field> getClassFields(Class<?> beanClass); static Optional<T> getAnnotation(Class<?> beanClass, Class<T> annotationClass); static Field findClassField(Class<?> beanClass, String fieldName); static Method findGetter(Class<?> beanClass, String fieldName); static String getGetterFieldName(Method getter); static Method findSetter(Class<?> beanClass, String fieldName, Class<?> fieldType); static List<Method> getClassGetters(Class<?> beanClass); static List<Method> getClassSetters(Class<?> beanClass); static Method findMethodWith(Class<?> searchClass, Class<? extends Annotation> annotationClass); static T newInstance(Class<T> clazz); static boolean isBooleanGetter(Method method); static Class<?> getRawType(Type type); static boolean isPrimitiveType(Class<?> type); static Type getElementType(Type genericType); static final String PREFIX_GETTER_IS; static final String PREFIX_GETTER_GET; }### Answer: @Test public void onGetSettersShouldReturnMethodsThatSetValue() throws Exception { List<Method> result = ClassUtils.getClassSetters(ParentClass.class); assertThat(result).containsOnly(ParentClass.class.getDeclaredMethod("setValue", String.class)); } @Test public void onClassInheritanceShouldReturnInheritedSetters() { List<Method> result = ClassUtils.getClassSetters(ChildClass.class); assertThat(result).hasSize(1); }
### Question: ClassUtils { public static <T> T newInstance(Class<T> clazz) { try { return clazz.newInstance(); } catch (InstantiationException \| IllegalAccessException e) { throw new ResourceException(String.format("couldn't create a new instance of %s", clazz), e); } } private ClassUtils(); static boolean existsClass(String className); static Class<?> loadClass(ClassLoader classLoader, String className); static List<Field> getClassFields(Class<?> beanClass); static Optional<T> getAnnotation(Class<?> beanClass, Class<T> annotationClass); static Field findClassField(Class<?> beanClass, String fieldName); static Method findGetter(Class<?> beanClass, String fieldName); static String getGetterFieldName(Method getter); static Method findSetter(Class<?> beanClass, String fieldName, Class<?> fieldType); static List<Method> getClassGetters(Class<?> beanClass); static List<Method> getClassSetters(Class<?> beanClass); static Method findMethodWith(Class<?> searchClass, Class<? extends Annotation> annotationClass); static T newInstance(Class<T> clazz); static boolean isBooleanGetter(Method method); static Class<?> getRawType(Type type); static boolean isPrimitiveType(Class<?> type); static Type getElementType(Type genericType); static final String PREFIX_GETTER_IS; static final String PREFIX_GETTER_GET; }### Answer: @Test public void onValidClassShouldCreateNewInstance() { ResourceClass result = ClassUtils.newInstance(ResourceClass.class); assertThat(result).isInstanceOf(ResourceClass.class); } @Test(expected = IllegalStateException.class) public void onClassWithCrushingConstructorShouldThrowException() { ClassUtils.newInstance(ClassWithCrashingConstructor.class); } @Test(expected = ResourceException.class) public void onClassWithoutDefaultConstructorShouldThrowException() { ClassUtils.newInstance(ClassWithoutDefaultConstructor.class); }
### Question: ClassUtils { public static Method findSetter(Class<?> beanClass, String fieldName, Class<?> fieldType) { String upperCaseName = fieldName.substring(0, 1).toUpperCase() + fieldName.substring(1); String methodName = "set" + upperCaseName; try { return beanClass.getMethod(methodName, fieldType); } catch (NoSuchMethodException e1) { } Method[] methods = beanClass.getMethods(); for (Method method : methods) { Class<?>[] params = method.getParameterTypes(); if (methodName.equals(method.getName()) && params.length == 1 && params[0].isAssignableFrom(fieldType)) { return method; } } return null; } private ClassUtils(); static boolean existsClass(String className); static Class<?> loadClass(ClassLoader classLoader, String className); static List<Field> getClassFields(Class<?> beanClass); static Optional<T> getAnnotation(Class<?> beanClass, Class<T> annotationClass); static Field findClassField(Class<?> beanClass, String fieldName); static Method findGetter(Class<?> beanClass, String fieldName); static String getGetterFieldName(Method getter); static Method findSetter(Class<?> beanClass, String fieldName, Class<?> fieldType); static List<Method> getClassGetters(Class<?> beanClass); static List<Method> getClassSetters(Class<?> beanClass); static Method findMethodWith(Class<?> searchClass, Class<? extends Annotation> annotationClass); static T newInstance(Class<T> clazz); static boolean isBooleanGetter(Method method); static Class<?> getRawType(Type type); static boolean isPrimitiveType(Class<?> type); static Type getElementType(Type genericType); static final String PREFIX_GETTER_IS; static final String PREFIX_GETTER_GET; }### Answer: @Test public void onFindSetterShouldReturnIntegerMethod() { Method method = ClassUtils.findSetter(IntegerClass.class, "id", Integer.class); assertThat(method.getName()).isEqualTo("setId"); }
### Question: ClassUtils { public static boolean isPrimitiveType(Class<?> type) { boolean isInt = type == byte.class \|\| type == short.class \|\| type == int.class \|\| type == long.class; boolean isDecimal = type == short.class \|\| type == double.class; return type == boolean.class \|\| isInt \|\| isDecimal; } private ClassUtils(); static boolean existsClass(String className); static Class<?> loadClass(ClassLoader classLoader, String className); static List<Field> getClassFields(Class<?> beanClass); static Optional<T> getAnnotation(Class<?> beanClass, Class<T> annotationClass); static Field findClassField(Class<?> beanClass, String fieldName); static Method findGetter(Class<?> beanClass, String fieldName); static String getGetterFieldName(Method getter); static Method findSetter(Class<?> beanClass, String fieldName, Class<?> fieldType); static List<Method> getClassGetters(Class<?> beanClass); static List<Method> getClassSetters(Class<?> beanClass); static Method findMethodWith(Class<?> searchClass, Class<? extends Annotation> annotationClass); static T newInstance(Class<T> clazz); static boolean isBooleanGetter(Method method); static Class<?> getRawType(Type type); static boolean isPrimitiveType(Class<?> type); static Type getElementType(Type genericType); static final String PREFIX_GETTER_IS; static final String PREFIX_GETTER_GET; }### Answer: @Test public void testIsPrimitiveType() { assertThat(ClassUtils.isPrimitiveType(boolean.class)).isTrue(); assertThat(ClassUtils.isPrimitiveType(byte.class)).isTrue(); assertThat(ClassUtils.isPrimitiveType(short.class)).isTrue(); assertThat(ClassUtils.isPrimitiveType(int.class)).isTrue(); assertThat(ClassUtils.isPrimitiveType(long.class)).isTrue(); assertThat(ClassUtils.isPrimitiveType(short.class)).isTrue(); assertThat(ClassUtils.isPrimitiveType(double.class)).isTrue(); assertThat(ClassUtils.isPrimitiveType(String.class)).isFalse(); assertThat(ClassUtils.isPrimitiveType(Object.class)).isFalse(); assertThat(ClassUtils.isPrimitiveType(int[].class)).isFalse(); }
### Question: PreconditionUtil { public static void assertTrue(String message, boolean condition) { verify(condition, message); } private PreconditionUtil(); static void assertEquals(String message, Object expected, Object actual); static void verifyEquals(Object expected, Object actual, String message, Object... args); static void fail(String message, Object... args); static void assertNotNull(String message, Object object); static void assertTrue(String message, boolean condition); static void assertTrue(boolean condition, String message, Object... args); static void assertFalse(boolean condition, String message, Object... args); static void assertFalse(String message, boolean condition); static void assertNull(String message, Object object); static void verify(boolean condition, String messageFormat, Object... args); }### Answer: @Test public void testConstructorIsPrivate() throws NoSuchMethodException, IllegalAccessException, InvocationTargetException, InstantiationException { Constructor<PreconditionUtil> constructor = PreconditionUtil.class.getDeclaredConstructor(); Assert.assertTrue(Modifier.isPrivate(constructor.getModifiers())); constructor.setAccessible(true); constructor.newInstance(); } @Test(expected = IllegalStateException.class) public void testTrueNotSatisfied() { PreconditionUtil.assertTrue(null, false); }
### Question: PreconditionUtil { public static void assertEquals(String message, Object expected, Object actual) { verifyEquals(expected, actual, message); } private PreconditionUtil(); static void assertEquals(String message, Object expected, Object actual); static void verifyEquals(Object expected, Object actual, String message, Object... args); static void fail(String message, Object... args); static void assertNotNull(String message, Object object); static void assertTrue(String message, boolean condition); static void assertTrue(boolean condition, String message, Object... args); static void assertFalse(boolean condition, String message, Object... args); static void assertFalse(String message, boolean condition); static void assertNull(String message, Object object); static void verify(boolean condition, String messageFormat, Object... args); }### Answer: @Test(expected = IllegalStateException.class) public void testObjectEqualsNotSatisfied() { PreconditionUtil.assertEquals("message", new Object(), new Object()); } @Test(expected = IllegalStateException.class) public void testEqualsNotSatisfied() { PreconditionUtil.assertEquals(null, 1, 2); } @Test(expected = IllegalStateException.class) public void testEqualsNotSatisfied2() { PreconditionUtil.assertEquals(null, "a", "b"); }
### Question: PreconditionUtil { public static void assertFalse(boolean condition, String message, Object... args) { verify(!condition, message, args); } private PreconditionUtil(); static void assertEquals(String message, Object expected, Object actual); static void verifyEquals(Object expected, Object actual, String message, Object... args); static void fail(String message, Object... args); static void assertNotNull(String message, Object object); static void assertTrue(String message, boolean condition); static void assertTrue(boolean condition, String message, Object... args); static void assertFalse(boolean condition, String message, Object... args); static void assertFalse(String message, boolean condition); static void assertNull(String message, Object object); static void verify(boolean condition, String messageFormat, Object... args); }### Answer: @Test(expected = IllegalStateException.class) public void testFalseNotSatisfied() { PreconditionUtil.assertFalse(null, true); }
### Question: PreconditionUtil { public static void assertNotNull(String message, Object object) { assertTrue(message, object != null); } private PreconditionUtil(); static void assertEquals(String message, Object expected, Object actual); static void verifyEquals(Object expected, Object actual, String message, Object... args); static void fail(String message, Object... args); static void assertNotNull(String message, Object object); static void assertTrue(String message, boolean condition); static void assertTrue(boolean condition, String message, Object... args); static void assertFalse(boolean condition, String message, Object... args); static void assertFalse(String message, boolean condition); static void assertNull(String message, Object object); static void verify(boolean condition, String messageFormat, Object... args); }### Answer: @Test(expected = IllegalStateException.class) public void testNotNullNotSatisfied() { PreconditionUtil.assertNotNull(null, null); }
### Question: PreconditionUtil { public static void assertNull(String message, Object object) { assertTrue(message, object == null); } private PreconditionUtil(); static void assertEquals(String message, Object expected, Object actual); static void verifyEquals(Object expected, Object actual, String message, Object... args); static void fail(String message, Object... args); static void assertNotNull(String message, Object object); static void assertTrue(String message, boolean condition); static void assertTrue(boolean condition, String message, Object... args); static void assertFalse(boolean condition, String message, Object... args); static void assertFalse(String message, boolean condition); static void assertNull(String message, Object object); static void verify(boolean condition, String messageFormat, Object... args); }### Answer: @Test(expected = IllegalStateException.class) public void testNullNotSatisfied() { PreconditionUtil.assertNull(null, "not null"); }
### Question: CompareUtils { public static boolean isEquals(Object a, Object b) { return (a == b) \|\| (a != null && a.equals(b)); } private CompareUtils(); static boolean isEquals(Object a, Object b); }### Answer: @Test public void test() { Assert.assertTrue(CompareUtils.isEquals("a", "a")); Assert.assertFalse(CompareUtils.isEquals(null, "a")); Assert.assertFalse(CompareUtils.isEquals("a", null)); Assert.assertTrue(CompareUtils.isEquals(null, null)); Assert.assertFalse(CompareUtils.isEquals("b", "a")); }
### Question: UrlUtils { public static String removeTrailingSlash(String url) { if (url != null && url.endsWith("/")) { return url.substring(0, url.length() - 1); } else { return url; } } private UrlUtils(); static String removeTrailingSlash(String url); static String addTrailingSlash(String url); static String removeLeadingSlash(String url); static String addLeadingSlash(String url); static String concat(String baseUrl, String... paths); static String appendRelativePath(String baseUrl, String relativePath); }### Answer: @Test public void testRemoveTrailingSlash() { Assert.assertNull(UrlUtils.removeTrailingSlash(null)); Assert.assertEquals("/test", UrlUtils.removeTrailingSlash("/test/")); Assert.assertEquals("test", UrlUtils.removeTrailingSlash("test/")); Assert.assertEquals("/test", UrlUtils.removeTrailingSlash("/test")); Assert.assertEquals("test", UrlUtils.removeTrailingSlash("test")); }
### Question: UrlUtils { public static String removeLeadingSlash(String url) { if (url != null && url.startsWith("/")) { return url.substring(1); } else { return url; } } private UrlUtils(); static String removeTrailingSlash(String url); static String addTrailingSlash(String url); static String removeLeadingSlash(String url); static String addLeadingSlash(String url); static String concat(String baseUrl, String... paths); static String appendRelativePath(String baseUrl, String relativePath); }### Answer: @Test public void testRemoveLeadingSlash() { Assert.assertNull(UrlUtils.removeLeadingSlash(null)); Assert.assertEquals("test/", UrlUtils.removeLeadingSlash("/test/")); Assert.assertEquals("test/", UrlUtils.removeLeadingSlash("test/")); Assert.assertEquals("test", UrlUtils.removeLeadingSlash("/test")); Assert.assertEquals("test", UrlUtils.removeLeadingSlash("test")); }
### Question: IOUtils { public static byte[] readFully(InputStream is) throws IOException { int nRead; ByteArrayOutputStream buffer = new ByteArrayOutputStream(); byte[] data = new byte[16384]; while ((nRead = is.read(data, 0, data.length)) != -1) { buffer.write(data, 0, nRead); } buffer.flush(); return buffer.toByteArray(); } private IOUtils(); static byte[] readFully(InputStream is); static void writeFile(File file, String text); }### Answer: @Test public void readFully() throws IOException { Random r = new Random(); for (int i = 0; i < 100; i++) { byte[] b = new byte[i * 100]; r.nextBytes(b); Assert.assertTrue(Arrays.equals(b, IOUtils.readFully(new ByteArrayInputStream(b)))); } }
### Question: JsonApiUrlBuilder implements UrlBuilder { @Override public String buildUrl(QueryContext queryContext, Object resource) { RegistryEntry entry = moduleRegistry.getResourceRegistry().findEntry(resource); ResourceInformation resourceInformation = entry.getResourceInformation(); Object id = resourceInformation.getId(resource); return buildUrl(queryContext, resourceInformation, id, null); } JsonApiUrlBuilder(ModuleRegistry moduleRegistry); @Override void addPropagatedParameter(String name); @Override Set<String> getPropagatedParameters(); @Override String buildUrl(QueryContext queryContext, Object resource); @Override String buildUrl(QueryContext queryContext, Object resource, QuerySpec querySpec); @Override String buildUrl(QueryContext queryContext, Object resource, QuerySpec querySpec, String relationshipName); @Override String buildUrl(QueryContext queryContext, Object resource, QuerySpec querySpec, String relationshipName, boolean selfLink); @Override String buildUrl(QueryContext queryContext, ResourceInformation resourceInformation); @Override String buildUrl(QueryContext queryContext, ResourceInformation resourceInformation, Object id, QuerySpec querySpec); @Override String buildUrl(QueryContext queryContext, ResourceInformation resourceInformation, Object id, QuerySpec querySpec, String relationshipName); String buildUrl(QueryContext queryContext, ResourceInformation resourceInformation, Object id, QuerySpec querySpec, String relationshipName, boolean selfLink); @Override String filterUrl(String url, QueryContext queryContext); }### Answer: @Test public void test() { QuerySpec querySpec = new QuerySpec(Task.class); querySpec.addFilter(PathSpec.of("name").filter(FilterOperator.EQ, "bar")); Assert.assertEquals("http: Assert.assertEquals("http: Assert.assertEquals("http: Assert.assertEquals("http: }
### Question: MethodCache { public Optional<Method> find(Class<?> clazz, String name, Class<?>... parameters) { MethodCacheKey entry = new MethodCacheKey(clazz, name, parameters); Optional<Method> method = cache.get(entry); if (method == null) { try { method = Optional.of(clazz.getMethod(name, parameters)); } catch (NoSuchMethodException e) { method = Optional.empty(); } cache.put(entry, method); } return method; } Optional<Method> find(Class<?> clazz, String name, Class<?>... parameters); }### Answer: @Test public void testMethod() { MethodCache cache = new MethodCache(); Optional<Method> method = cache.find(Date.class, "parse", String.class); Assert.assertTrue(method.isPresent()); Assert.assertEquals("parse", method.get().getName()); Optional<Method> method2 = cache.find(Date.class, "parse", String.class); Assert.assertSame(method, method2); } @Test public void testNonExistingMethod() { MethodCache cache = new MethodCache(); Optional<Method> method = cache.find(Date.class, "doesNotExist", String.class); Assert.assertFalse(method.isPresent()); }
### Question: ResourceDeleteController extends BaseController { @Override public boolean isAcceptable(JsonPath jsonPath, String method) { return jsonPath instanceof ResourcePath && HttpMethod.DELETE.name().equals(method); } @Override boolean isAcceptable(JsonPath jsonPath, String method); @Override Result<Response> handleAsync(JsonPath jsonPath, QueryAdapter queryAdapter, Document requestDocument); }### Answer: @Test public void onValidRequestShouldAcceptIt() { JsonPath jsonPath = pathBuilder.build("tasks/1", queryContext); ResourceDeleteController sut = new ResourceDeleteController(); sut.init(controllerContext); boolean result = sut.isAcceptable(jsonPath, REQUEST_TYPE); assertThat(result).isTrue(); } @Test public void onNonRelationRequestShouldDenyIt() { JsonPath jsonPath = pathBuilder.build("tasks/1/relationships/project", queryContext); ResourceDeleteController sut = new ResourceDeleteController(); sut.init(controllerContext); boolean result = sut.isAcceptable(jsonPath, REQUEST_TYPE); assertThat(result).isFalse(); }
### Question: CollectionGetController extends ResourceIncludeField { @Override public boolean isAcceptable(JsonPath jsonPath, String method) { return jsonPath.isCollection() && jsonPath instanceof ResourcePath && HttpMethod.GET.name().equals(method); } @Override boolean isAcceptable(JsonPath jsonPath, String method); @Override Result<Response> handleAsync(JsonPath jsonPath, QueryAdapter queryAdapter, Document requestBody); Response toResponse(Document document); }### Answer: @Test public void onGivenRequestCollectionGetShouldAcceptIt() { JsonPath jsonPath = pathBuilder.build("/tasks/", queryContext); CollectionGetController sut = new CollectionGetController(); sut.init(controllerContext); boolean result = sut.isAcceptable(jsonPath, REQUEST_TYPE); Assert.assertEquals(result, true); } @Test public void onGivenRequestCollectionGetShouldDenyIt() { JsonPath jsonPath = pathBuilder.build("/tasks/2", queryContext); CollectionGetController sut = new CollectionGetController(); sut.init(controllerContext); boolean result = sut.isAcceptable(jsonPath, REQUEST_TYPE); Assert.assertEquals(result, false); }
### Question: ResourceGetController extends ResourceIncludeField { @Override public boolean isAcceptable(JsonPath jsonPath, String method) { return !jsonPath.isCollection() && jsonPath instanceof ResourcePath && HttpMethod.GET.name().equals(method); } @Override boolean isAcceptable(JsonPath jsonPath, String method); @Override Result<Response> handleAsync(JsonPath jsonPath, QueryAdapter queryAdapter, Document requestBody); Response toResponse(Document document); }### Answer: @Test public void onGivenRequestCollectionGetShouldDenyIt() { JsonPath jsonPath = pathBuilder.build("/tasks/", queryContext); ResourceGetController sut = new ResourceGetController(); sut.init(controllerContext); boolean result = sut.isAcceptable(jsonPath, REQUEST_TYPE); Assert.assertEquals(result, false); } @Test public void onGivenRequestResourceGetShouldAcceptIt() { JsonPath jsonPath = pathBuilder.build("/tasks/2", queryContext); ResourceGetController sut = new ResourceGetController(); sut.init(controllerContext); boolean result = sut.isAcceptable(jsonPath, REQUEST_TYPE); Assert.assertEquals(result, true); } @Test public void onMethodMismatchShouldDenyIt() { JsonPath jsonPath = pathBuilder.build("/tasks/2", queryContext); ResourceGetController sut = new ResourceGetController(); sut.init(controllerContext); boolean result = sut.isAcceptable(jsonPath, "POST"); Assert.assertEquals(result, false); }
### Question: ResourcePostController extends ResourceUpsert { @Override public boolean isAcceptable(JsonPath jsonPath, String method) { boolean nestedOne = jsonPath.getParentField() != null && !jsonPath.getParentField().isCollection(); return (jsonPath.isCollection() \|\| nestedOne) && jsonPath instanceof ResourcePath && HttpMethod.POST.name().equals(method); } @Override boolean isAcceptable(JsonPath jsonPath, String method); @Override Result<Response> handleAsync(JsonPath jsonPath, QueryAdapter queryAdapter, Document requestDocument); }### Answer: @Test public void onGivenRequestCollectionGetShouldDenyIt() { JsonPath jsonPath = pathBuilder.build("/tasks/1", queryContext); ResourcePostController sut = new ResourcePostController(); sut.init(controllerContext); boolean result = sut.isAcceptable(jsonPath, REQUEST_TYPE); Assert.assertEquals(result, false); } @Test public void onGivenRequestResourceGetShouldAcceptIt() { JsonPath jsonPath = pathBuilder.build("/tasks/", queryContext); ResourcePostController sut = new ResourcePostController(); sut.init(controllerContext); boolean result = sut.isAcceptable(jsonPath, REQUEST_TYPE); Assert.assertEquals(result, true); }
### Question: ResourcePatchController extends ResourceUpsert { @Override public boolean isAcceptable(JsonPath jsonPath, String method) { return !jsonPath.isCollection() && jsonPath instanceof ResourcePath && HttpMethod.PATCH.name().equals(method); } @Override boolean isAcceptable(JsonPath jsonPath, String method); @Override Result<Response> handleAsync(JsonPath jsonPath, QueryAdapter queryAdapter, Document requestDocument); }### Answer: @Test public void onGivenRequestCollectionGetShouldDenyIt() { JsonPath jsonPath = pathBuilder.build("/tasks/", queryContext); ResourcePatchController sut = new ResourcePatchController(); sut.init(controllerContext); boolean result = sut.isAcceptable(jsonPath, REQUEST_TYPE); Assert.assertEquals(result, false); } @Test public void onGivenRequestResourceGetShouldAcceptIt() { JsonPath jsonPath = pathBuilder.build("/tasks/1", queryContext); ResourcePatchController sut = new ResourcePatchController(); sut.init(controllerContext); boolean result = sut.isAcceptable(jsonPath, REQUEST_TYPE); Assert.assertEquals(result, true); }
### Question: TypeParser { public String toString(Object input) { if (input == null) { return null; } Class<?> clazz = input.getClass(); if (String.class.equals(clazz)) { return (String) input; } StringMapper mapper = getMapper(clazz); if (mapper == null) { throw new ParserException(String.format("Cannot map to %s : %s", clazz.getName(), input)); } return mapper.toString(input); } TypeParser(); boolean isEnforceJackson(); void setEnforceJackson(boolean enforceJackson); boolean isUseJackson(); void setUseJackson(boolean useJackson); void addParser(Class<T> clazz, StringParser<T> parser); void addMapper(Class<T> clazz, StringMapper<T> mapper); Iterable<T> parse(Iterable<String> inputs, Class<T> clazz); T parse(String input, Class<T> clazz); String toString(Object input); StringMapper<T> getMapper(Class<T> clazz); boolean supports(Class<?> clazz); void setObjectMapper(ObjectMapper objectMapper); StringParser<T> getParser(Class<T> clazz); final Map<Class, StringParser> parsers; final Map<Class, StringMapper> mappers; }### Answer: @Test public void checkBooleanToString() { assertThat(sut.toString(Boolean.FALSE)).isEqualTo("false"); assertThat(sut.toString(Boolean.TRUE)).isEqualTo("true"); } @Test public void checkNullToString() { assertThat(sut.toString(null)).isNull(); }
### Question: TypeParser { public <T> void addParser(Class<T> clazz, StringParser<T> parser) { parsers.put(clazz, parser); } TypeParser(); boolean isEnforceJackson(); void setEnforceJackson(boolean enforceJackson); boolean isUseJackson(); void setUseJackson(boolean useJackson); void addParser(Class<T> clazz, StringParser<T> parser); void addMapper(Class<T> clazz, StringMapper<T> mapper); Iterable<T> parse(Iterable<String> inputs, Class<T> clazz); T parse(String input, Class<T> clazz); String toString(Object input); StringMapper<T> getMapper(Class<T> clazz); boolean supports(Class<?> clazz); void setObjectMapper(ObjectMapper objectMapper); StringParser<T> getParser(Class<T> clazz); final Map<Class, StringParser> parsers; final Map<Class, StringMapper> mappers; }### Answer: @Test public void testAddParser() { sut.addParser(Boolean.class, new StringParser<Boolean>() { @Override public Boolean parse(String input) { return true; } }); Assert.assertTrue(sut.parse("input", Boolean.class)); }
### Question: Nullable { public static <T> Nullable<T> ofNullable(T value) { return value == null ? Nullable.empty() : of(value); } private Nullable(); private Nullable(T value); @SuppressWarnings("unchecked") static Nullable<T> empty(); static Nullable<T> of(T value); static Nullable<T> ofNullable(T value); static Nullable<T> nullValue(); boolean isPresent(); T get(); @Override int hashCode(); @Override boolean equals(Object obj); }### Answer: @Test public void ofNullable() { Assert.assertEquals(13, Nullable.ofNullable(13).get().intValue()); Assert.assertFalse(Nullable.ofNullable(null).isPresent()); }
### Question: SimpleModule implements Module { @Override public String getModuleName() { return moduleName; } SimpleModule(String moduleName); @Override String getModuleName(); @Override void setupModule(ModuleContext context); void addResourceInformationProvider(ResourceInformationProvider resourceInformationProvider); void addRepositoryInformationBuilder(RepositoryInformationProvider repositoryInformationProvider); void addExceptionMapperLookup(ExceptionMapperLookup exceptionMapperLookup); void addExceptionMapper(@SuppressWarnings("rawtypes") ExceptionMapper exceptionMapper); Map<String, ResourceRegistryPart> getRegistryParts(); void addExtension(ModuleExtension extension); void addFilter(DocumentFilter filter); void addRepositoryFilter(RepositoryFilter filter); void addResourceFilter(ResourceFilter filter); void addHttpStatusBehavior(HttpStatusBehavior httpStatusBehavior); void addResourceFieldContributor(ResourceFieldContributor resourceFieldContributor); void addResourceModificationFilter(ResourceModificationFilter filter); void addRepositoryDecoratorFactory(RepositoryDecoratorFactory decorator); void addSecurityProvider(SecurityProvider securityProvider); void addJacksonModule(com.fasterxml.jackson.databind.Module module); void addPagingBehavior(PagingBehavior pagingBehavior); List<PagingBehavior> getPagingBehaviors(); void addResourceLookup(ResourceLookup resourceLookup); void addRepository(Object repository); List<Object> getRepositories(); List<ExceptionMapperLookup> getExceptionMapperLookups(); List<SecurityProvider> getSecurityProviders(); List<HttpStatusBehavior> getHttpStatusBehaviors(); void addHttpRequestProcessor(HttpRequestProcessor httpRequestProcessor); List<HttpRequestProcessor> getHttpRequestProcessors(); void addRepositoryAdapterFactory(RepositoryAdapterFactory repositoryAdapterFactory); List<RepositoryAdapterFactory> getRepositoryAdapterFactories(); void addNamingStrategy(NamingStrategy namingStrategy); List<NamingStrategy> getNamingStrategies(); void addRegistryPart(String prefix, ResourceRegistryPart part); List<RegistryEntry> getRegistryEntries(); void addRegistryEntry(RegistryEntry entry); }### Answer: @Test public void testGetModuleName() { Assert.assertEquals("simple", module.getModuleName()); }
### Question: DefaultServiceDiscoveryFactory implements ServiceDiscoveryFactory { @Override public ServiceDiscovery getInstance() { ServiceLoader<ServiceDiscovery> loader = ServiceLoader.load(ServiceDiscovery.class); Iterator<ServiceDiscovery> iterator = loader.iterator(); if (iterator.hasNext()) { ServiceDiscovery discovery = iterator.next(); PreconditionUtil.verify(!iterator.hasNext(), "expected unique ServiceDiscovery implementation, got: %s", loader); return discovery; } return new EmptyServiceDiscovery(); } @Override ServiceDiscovery getInstance(); }### Answer: @Test public void test() { DefaultServiceDiscoveryFactory factory = new DefaultServiceDiscoveryFactory(); ServiceDiscovery instance = factory.getInstance(); Assert.assertTrue(instance instanceof TestServiceDiscovery); }
### Question: CrnkBoot { public void setObjectMapper(ObjectMapper objectMapper) { checkNotConfiguredYet(); PreconditionUtil.verify(this.objectMapper == null, "ObjectMapper already set"); this.objectMapper = objectMapper; } void putServerInfo(String key, String value); void setServiceDiscoveryFactory(ServiceDiscoveryFactory factory); void addModule(Module module); void setServiceUrlProvider(ServiceUrlProvider serviceUrlProvider); void boot(); ExceptionMapperRegistry getExceptionMapperRegistry(); DocumentMapper getDocumentMapper(); UrlBuilder getUrlBuilder(); HttpRequestDispatcherImpl getRequestDispatcher(); ResourceRegistry getResourceRegistry(); ObjectMapper getObjectMapper(); void setObjectMapper(ObjectMapper objectMapper); PropertiesProvider getPropertiesProvider(); void setPropertiesProvider(PropertiesProvider propertiesProvider); String getWebPathPrefix(); ServiceDiscovery getServiceDiscovery(); void setServiceDiscovery(ServiceDiscovery serviceDiscovery); void setDefaultPageLimit(Long defaultPageLimit); void setMaxPageLimit(Long maxPageLimit); void setAllowUnknownAttributes(); void setAllowUnknownParameters(); ModuleRegistry getModuleRegistry(); void setUrlMapper(QuerySpecUrlMapper urlMapper); boolean isNullDataResponseEnabled(); ServiceUrlProvider getServiceUrlProvider(); List<PagingBehavior> getPagingBehaviors(); ControllerRegistry getControllerRegistry(); QueryAdapterBuilder getQueryAdapterBuilder(); CoreModule getCoreModule(); QuerySpecUrlMapper getUrlMapper(); void setWebPathPrefix(String webPathPrefix); }### Answer: @Test public void setObjectMapper() { CrnkBoot boot = new CrnkBoot(); ObjectMapper mapper = new ObjectMapper(); boot.setObjectMapper(mapper); Assert.assertSame(mapper, boot.getObjectMapper()); }
### Question: CrnkBoot { public void setServiceDiscovery(ServiceDiscovery serviceDiscovery) { LOGGER.debug("set service discovery {}", serviceDiscovery); PreconditionUtil.verify(this.serviceDiscovery == null, "serviceDiscovery already set: %s", this.serviceDiscovery); this.serviceDiscovery = serviceDiscovery; moduleRegistry.setServiceDiscovery(serviceDiscovery); } void putServerInfo(String key, String value); void setServiceDiscoveryFactory(ServiceDiscoveryFactory factory); void addModule(Module module); void setServiceUrlProvider(ServiceUrlProvider serviceUrlProvider); void boot(); ExceptionMapperRegistry getExceptionMapperRegistry(); DocumentMapper getDocumentMapper(); UrlBuilder getUrlBuilder(); HttpRequestDispatcherImpl getRequestDispatcher(); ResourceRegistry getResourceRegistry(); ObjectMapper getObjectMapper(); void setObjectMapper(ObjectMapper objectMapper); PropertiesProvider getPropertiesProvider(); void setPropertiesProvider(PropertiesProvider propertiesProvider); String getWebPathPrefix(); ServiceDiscovery getServiceDiscovery(); void setServiceDiscovery(ServiceDiscovery serviceDiscovery); void setDefaultPageLimit(Long defaultPageLimit); void setMaxPageLimit(Long maxPageLimit); void setAllowUnknownAttributes(); void setAllowUnknownParameters(); ModuleRegistry getModuleRegistry(); void setUrlMapper(QuerySpecUrlMapper urlMapper); boolean isNullDataResponseEnabled(); ServiceUrlProvider getServiceUrlProvider(); List<PagingBehavior> getPagingBehaviors(); ControllerRegistry getControllerRegistry(); QueryAdapterBuilder getQueryAdapterBuilder(); CoreModule getCoreModule(); QuerySpecUrlMapper getUrlMapper(); void setWebPathPrefix(String webPathPrefix); }### Answer: @Test public void setServiceDiscovery() { CrnkBoot boot = new CrnkBoot(); ServiceDiscovery serviceDiscovery = mock(ServiceDiscovery.class); boot.setServiceDiscovery(serviceDiscovery); Assert.assertSame(serviceDiscovery, boot.getServiceDiscovery()); }
### Question: CrnkBoot { public void setServiceDiscoveryFactory(ServiceDiscoveryFactory factory) { checkNotConfiguredYet(); PreconditionUtil.verify(serviceDiscovery == null, "serviceDiscovery already initialized: %s", serviceDiscovery); this.serviceDiscoveryFactory = factory; } void putServerInfo(String key, String value); void setServiceDiscoveryFactory(ServiceDiscoveryFactory factory); void addModule(Module module); void setServiceUrlProvider(ServiceUrlProvider serviceUrlProvider); void boot(); ExceptionMapperRegistry getExceptionMapperRegistry(); DocumentMapper getDocumentMapper(); UrlBuilder getUrlBuilder(); HttpRequestDispatcherImpl getRequestDispatcher(); ResourceRegistry getResourceRegistry(); ObjectMapper getObjectMapper(); void setObjectMapper(ObjectMapper objectMapper); PropertiesProvider getPropertiesProvider(); void setPropertiesProvider(PropertiesProvider propertiesProvider); String getWebPathPrefix(); ServiceDiscovery getServiceDiscovery(); void setServiceDiscovery(ServiceDiscovery serviceDiscovery); void setDefaultPageLimit(Long defaultPageLimit); void setMaxPageLimit(Long maxPageLimit); void setAllowUnknownAttributes(); void setAllowUnknownParameters(); ModuleRegistry getModuleRegistry(); void setUrlMapper(QuerySpecUrlMapper urlMapper); boolean isNullDataResponseEnabled(); ServiceUrlProvider getServiceUrlProvider(); List<PagingBehavior> getPagingBehaviors(); ControllerRegistry getControllerRegistry(); QueryAdapterBuilder getQueryAdapterBuilder(); CoreModule getCoreModule(); QuerySpecUrlMapper getUrlMapper(); void setWebPathPrefix(String webPathPrefix); }### Answer: @Test public void setServiceDiscoveryFactory() { CrnkBoot boot = new CrnkBoot(); boot.setServiceDiscoveryFactory(serviceDiscoveryFactory); boot.setServiceUrlProvider(mock(ServiceUrlProvider.class)); boot.boot(); Mockito.verify(serviceDiscoveryFactory, Mockito.times(1)).getInstance(); Assert.assertNotNull(boot.getServiceDiscovery()); }
### Question: CrnkBoot { public PropertiesProvider getPropertiesProvider() { return propertiesProvider; } void putServerInfo(String key, String value); void setServiceDiscoveryFactory(ServiceDiscoveryFactory factory); void addModule(Module module); void setServiceUrlProvider(ServiceUrlProvider serviceUrlProvider); void boot(); ExceptionMapperRegistry getExceptionMapperRegistry(); DocumentMapper getDocumentMapper(); UrlBuilder getUrlBuilder(); HttpRequestDispatcherImpl getRequestDispatcher(); ResourceRegistry getResourceRegistry(); ObjectMapper getObjectMapper(); void setObjectMapper(ObjectMapper objectMapper); PropertiesProvider getPropertiesProvider(); void setPropertiesProvider(PropertiesProvider propertiesProvider); String getWebPathPrefix(); ServiceDiscovery getServiceDiscovery(); void setServiceDiscovery(ServiceDiscovery serviceDiscovery); void setDefaultPageLimit(Long defaultPageLimit); void setMaxPageLimit(Long maxPageLimit); void setAllowUnknownAttributes(); void setAllowUnknownParameters(); ModuleRegistry getModuleRegistry(); void setUrlMapper(QuerySpecUrlMapper urlMapper); boolean isNullDataResponseEnabled(); ServiceUrlProvider getServiceUrlProvider(); List<PagingBehavior> getPagingBehaviors(); ControllerRegistry getControllerRegistry(); QueryAdapterBuilder getQueryAdapterBuilder(); CoreModule getCoreModule(); QuerySpecUrlMapper getUrlMapper(); void setWebPathPrefix(String webPathPrefix); }### Answer: @Test public void getPropertiesProvider() { CrnkBoot boot = new CrnkBoot(); boot.setServiceDiscoveryFactory(serviceDiscoveryFactory); boot.setServiceUrlProvider(mock(ServiceUrlProvider.class)); boot.boot(); Assert.assertNotNull(boot.getPropertiesProvider()); }
### Question: CrnkBoot { public void setServiceUrlProvider(ServiceUrlProvider serviceUrlProvider) { checkNotConfiguredYet(); this.moduleRegistry.getHttpRequestContextProvider().setServiceUrlProvider(serviceUrlProvider); } void putServerInfo(String key, String value); void setServiceDiscoveryFactory(ServiceDiscoveryFactory factory); void addModule(Module module); void setServiceUrlProvider(ServiceUrlProvider serviceUrlProvider); void boot(); ExceptionMapperRegistry getExceptionMapperRegistry(); DocumentMapper getDocumentMapper(); UrlBuilder getUrlBuilder(); HttpRequestDispatcherImpl getRequestDispatcher(); ResourceRegistry getResourceRegistry(); ObjectMapper getObjectMapper(); void setObjectMapper(ObjectMapper objectMapper); PropertiesProvider getPropertiesProvider(); void setPropertiesProvider(PropertiesProvider propertiesProvider); String getWebPathPrefix(); ServiceDiscovery getServiceDiscovery(); void setServiceDiscovery(ServiceDiscovery serviceDiscovery); void setDefaultPageLimit(Long defaultPageLimit); void setMaxPageLimit(Long maxPageLimit); void setAllowUnknownAttributes(); void setAllowUnknownParameters(); ModuleRegistry getModuleRegistry(); void setUrlMapper(QuerySpecUrlMapper urlMapper); boolean isNullDataResponseEnabled(); ServiceUrlProvider getServiceUrlProvider(); List<PagingBehavior> getPagingBehaviors(); ControllerRegistry getControllerRegistry(); QueryAdapterBuilder getQueryAdapterBuilder(); CoreModule getCoreModule(); QuerySpecUrlMapper getUrlMapper(); void setWebPathPrefix(String webPathPrefix); }### Answer: @Test public void setServiceUrlProvider() { CrnkBoot boot = new CrnkBoot(); boot.setServiceDiscoveryFactory(serviceDiscoveryFactory); ServiceUrlProvider serviceUrlProvider = mock(ServiceUrlProvider.class); boot.setServiceUrlProvider(serviceUrlProvider); boot.boot(); Assert.assertEquals(serviceUrlProvider, boot.getServiceUrlProvider()); }
### Question: CrnkBoot { public void setAllowUnknownAttributes() { this.allowUnknownAttributes = true; } void putServerInfo(String key, String value); void setServiceDiscoveryFactory(ServiceDiscoveryFactory factory); void addModule(Module module); void setServiceUrlProvider(ServiceUrlProvider serviceUrlProvider); void boot(); ExceptionMapperRegistry getExceptionMapperRegistry(); DocumentMapper getDocumentMapper(); UrlBuilder getUrlBuilder(); HttpRequestDispatcherImpl getRequestDispatcher(); ResourceRegistry getResourceRegistry(); ObjectMapper getObjectMapper(); void setObjectMapper(ObjectMapper objectMapper); PropertiesProvider getPropertiesProvider(); void setPropertiesProvider(PropertiesProvider propertiesProvider); String getWebPathPrefix(); ServiceDiscovery getServiceDiscovery(); void setServiceDiscovery(ServiceDiscovery serviceDiscovery); void setDefaultPageLimit(Long defaultPageLimit); void setMaxPageLimit(Long maxPageLimit); void setAllowUnknownAttributes(); void setAllowUnknownParameters(); ModuleRegistry getModuleRegistry(); void setUrlMapper(QuerySpecUrlMapper urlMapper); boolean isNullDataResponseEnabled(); ServiceUrlProvider getServiceUrlProvider(); List<PagingBehavior> getPagingBehaviors(); ControllerRegistry getControllerRegistry(); QueryAdapterBuilder getQueryAdapterBuilder(); CoreModule getCoreModule(); QuerySpecUrlMapper getUrlMapper(); void setWebPathPrefix(String webPathPrefix); }### Answer: @Test public void setAllowUnknownAttributes() { CrnkBoot boot = new CrnkBoot(); boot.setAllowUnknownAttributes(); boot.boot(); DefaultQuerySpecUrlMapper urlMapper = (DefaultQuerySpecUrlMapper) boot.getUrlMapper(); Assert.assertTrue(urlMapper.getAllowUnknownAttributes()); }
### Question: CrnkBoot { public void setAllowUnknownParameters() { this.allowUnknownParameters = true; } void putServerInfo(String key, String value); void setServiceDiscoveryFactory(ServiceDiscoveryFactory factory); void addModule(Module module); void setServiceUrlProvider(ServiceUrlProvider serviceUrlProvider); void boot(); ExceptionMapperRegistry getExceptionMapperRegistry(); DocumentMapper getDocumentMapper(); UrlBuilder getUrlBuilder(); HttpRequestDispatcherImpl getRequestDispatcher(); ResourceRegistry getResourceRegistry(); ObjectMapper getObjectMapper(); void setObjectMapper(ObjectMapper objectMapper); PropertiesProvider getPropertiesProvider(); void setPropertiesProvider(PropertiesProvider propertiesProvider); String getWebPathPrefix(); ServiceDiscovery getServiceDiscovery(); void setServiceDiscovery(ServiceDiscovery serviceDiscovery); void setDefaultPageLimit(Long defaultPageLimit); void setMaxPageLimit(Long maxPageLimit); void setAllowUnknownAttributes(); void setAllowUnknownParameters(); ModuleRegistry getModuleRegistry(); void setUrlMapper(QuerySpecUrlMapper urlMapper); boolean isNullDataResponseEnabled(); ServiceUrlProvider getServiceUrlProvider(); List<PagingBehavior> getPagingBehaviors(); ControllerRegistry getControllerRegistry(); QueryAdapterBuilder getQueryAdapterBuilder(); CoreModule getCoreModule(); QuerySpecUrlMapper getUrlMapper(); void setWebPathPrefix(String webPathPrefix); }### Answer: @Test public void setAllowUnknownParameters() { CrnkBoot boot = new CrnkBoot(); boot.setAllowUnknownParameters(); boot.boot(); DefaultQuerySpecUrlMapper urlMapper = (DefaultQuerySpecUrlMapper) boot.getUrlMapper(); Assert.assertTrue(urlMapper.getAllowUnknownParameters()); }
### Question: JaxrsRequestContext extends DefaultHttpRequestContextBase { @Override public byte[] getRequestBody() { if (!requestBody.isPresent()) { try { ByteArrayOutputStream buffer = new ByteArrayOutputStream(); int nRead; byte[] data = new byte[16384]; InputStream is = requestContext.getEntityStream(); while ((nRead = is.read(data, 0, data.length)) != -1) { buffer.write(data, 0, nRead); } buffer.flush(); requestBody = Nullable.of(buffer.toByteArray()); } catch (IOException e) { throw new IllegalStateException(e); } } return requestBody.get(); } JaxrsRequestContext(ContainerRequestContext requestContext, CrnkFeature feature); @Override HttpResponse getResponse(); @Override void setResponse(HttpResponse response); @Override Set<String> getRequestHeaderNames(); @Override String getRequestHeader(String name); @Override Map<String, Set<String>> getRequestParameters(); @Override String getPath(); @Override String getBaseUrl(); @Override byte[] getRequestBody(); @Override String getMethod(); @Override URI getNativeRequestUri(); void checkAbort(); }### Answer: @Test public void testRepeatedGetBody() { byte[] body = "Hello World".getBytes(); Mockito.when(requestContext.getEntityStream()).thenReturn(new ByteArrayInputStream(body)); byte[] copy1 = context.getRequestBody(); byte[] copy2 = context.getRequestBody(); Assert.assertSame(copy1, copy2); Assert.assertTrue(Arrays.equals(copy1, body)); }
### Question: JaxrsRequestContext extends DefaultHttpRequestContextBase { @Override public String getBaseUrl() { String baseUrl = requestContext.getUriInfo().getBaseUri().toString(); if (feature.getWebPathPrefix() == null) { return UrlUtils.removeTrailingSlash(baseUrl); } else { return UrlUtils.concat(baseUrl, feature.getWebPathPrefix()); } } JaxrsRequestContext(ContainerRequestContext requestContext, CrnkFeature feature); @Override HttpResponse getResponse(); @Override void setResponse(HttpResponse response); @Override Set<String> getRequestHeaderNames(); @Override String getRequestHeader(String name); @Override Map<String, Set<String>> getRequestParameters(); @Override String getPath(); @Override String getBaseUrl(); @Override byte[] getRequestBody(); @Override String getMethod(); @Override URI getNativeRequestUri(); void checkAbort(); }### Answer: @Test public void testGetBaseBath() { Mockito.when(feature.getWebPathPrefix()).thenReturn(null); Mockito.when(uriInfo.getBaseUri()).thenReturn(URI.create("/base")); Assert.assertEquals("/base", context.getBaseUrl());; } @Test public void testGetBaseBathWithWebpathPrefix() { Mockito.when(feature.getWebPathPrefix()).thenReturn("/api"); Mockito.when(uriInfo.getBaseUri()).thenReturn(URI.create("/base")); Assert.assertEquals("/base/api", context.getBaseUrl());; }
### Question: OASUtils { public static boolean oneToMany(MetaResourceField metaResourceField) { return metaResourceField.getType().isCollection() \|\| metaResourceField.getType().isMap(); } static Stream<MetaResourceField> attributes(MetaResource metaResource, boolean includePrimaryKey); static Stream<MetaResourceField> notAssociationAttributes(Stream<MetaResourceField> attributes); static Stream<MetaResourceField> associationAttributes(Stream<MetaResourceField> attributes); static Stream<MetaResourceField> notAssociationAttributes(MetaResource metaResource, boolean includePrimaryKey); static Stream<MetaResourceField> associationAttributes(MetaResource metaResource, boolean includePrimaryKey); static Stream<MetaResourceField> filterAttributes(MetaResource metaResource, boolean includePrimaryKey); static Stream<MetaResourceField> patchAttributes(MetaResource metaResource, boolean includePrimaryKey); static Stream<MetaResourceField> postAttributes(MetaResource metaResource, boolean includePrimaryKey); static Stream<MetaResourceField> sortAttributes(MetaResource metaResource, boolean includePrimaryKey); static MetaResourceField getPrimaryKeyMetaResourceField(MetaResource metaResource); static Predicate<T> not(Predicate<T> p); static Schema transformMetaResourceField(MetaType metaType); static boolean oneToMany(MetaResourceField metaResourceField); static String getResourcesPath(MetaResource metaResource); static String getResourcePath(MetaResource metaResource); static String getNestedPath(MetaResource metaResource, MetaResourceField metaResourceField); static String getRelationshipsPath(MetaResource metaResource, MetaResourceField metaResourceField); static List<Schema> getIncludedSchemaRefs(AbstractSchemaGenerator... schemas); }### Answer: @Test public void testOneToMany() { MetaResourceField metaResourceField = new MetaResourceField(); metaResourceField.setType(new MetaSetType()); Assert.assertTrue(OASUtils.oneToMany(metaResourceField)); metaResourceField.setType(new MetaMapType()); Assert.assertTrue(OASUtils.oneToMany(metaResourceField)); metaResourceField.setType(new MetaPrimitiveType()); Assert.assertFalse(OASUtils.oneToMany(metaResourceField)); }
### Question: ResourcesGet extends AbstractResourceOperation implements OASOperation { @Override public OperationType operationType() { return operationType; } ResourcesGet(MetaResource metaResource); @Override OperationType operationType(); @Override boolean isEnabled(); @Override String getDescription(); @Override Operation operation(); @Override String path(); static final OperationType operationType; }### Answer: @Test void operationType() { ResourcesGet resourcePost = new ResourcesGet(metaResource); Assert.assertEquals(OperationType.GET, resourcePost.operationType()); }
### Question: ResourcesGet extends AbstractResourceOperation implements OASOperation { @Override public boolean isEnabled() { return metaResource.isReadable(); } ResourcesGet(MetaResource metaResource); @Override OperationType operationType(); @Override boolean isEnabled(); @Override String getDescription(); @Override Operation operation(); @Override String path(); static final OperationType operationType; }### Answer: @Test void isEnabledTrueWhenReadable() { ResourcesGet resourcePost = new ResourcesGet(metaResource); Assert.assertTrue(metaResource.isReadable()); Assert.assertTrue(resourcePost.isEnabled()); } @Test void isEnabled() { ResourcesGet resourcePost = new ResourcesGet(metaResource); metaResource.setReadable(false); Assert.assertFalse(resourcePost.isEnabled()); }
### Question: ResourcesGet extends AbstractResourceOperation implements OASOperation { @Override public String getDescription() { return "Retrieve a List of " + metaResource.getResourceType() + " resources"; } ResourcesGet(MetaResource metaResource); @Override OperationType operationType(); @Override boolean isEnabled(); @Override String getDescription(); @Override Operation operation(); @Override String path(); static final OperationType operationType; }### Answer: @Test void getDescription() { ResourcesGet resourcePost = new ResourcesGet(metaResource); Assert.assertEquals("Retrieve a List of ResourceType resources", resourcePost.getDescription()); }
### Question: ResourcesGet extends AbstractResourceOperation implements OASOperation { @Override public Operation operation() { Operation operation = super.operation(); addFilters(metaResource, operation); operation.addParametersItem(new Fields(metaResource).$ref()); operation.addParametersItem(new Include(metaResource).$ref()); operation.addParametersItem(new Sort(metaResource).$ref()); operation.addParametersItem(new PageLimit().$ref()); operation.addParametersItem(new PageOffset().$ref()); responses.put("200", new ResourcesResponse(metaResource).$ref()); return operation.responses(apiResponsesFromMap(responses)); } ResourcesGet(MetaResource metaResource); @Override OperationType operationType(); @Override boolean isEnabled(); @Override String getDescription(); @Override Operation operation(); @Override String path(); static final OperationType operationType; }### Answer: @Test void operation() { Operation operation = new ResourcesGet(metaResource).operation(); Assert.assertTrue(operation.getResponses().containsKey("200")); }
### Question: ResourcesGet extends AbstractResourceOperation implements OASOperation { @Override public String path() { return OASUtils.getResourcesPath(metaResource); } ResourcesGet(MetaResource metaResource); @Override OperationType operationType(); @Override boolean isEnabled(); @Override String getDescription(); @Override Operation operation(); @Override String path(); static final OperationType operationType; }### Answer: @Test void path() { ResourcesGet resourcePost = new ResourcesGet(metaResource); Assert.assertEquals("/ResourcePath", resourcePost.path()); }
### Question: NestedDelete extends AbstractNestedDeleteOperation implements OASOperation { @Override public OperationType operationType() { return operationType; } NestedDelete(MetaResource metaResource, MetaResourceField metaResourceField, MetaResource relatedMetaResource); @Override OperationType operationType(); @Override boolean isEnabled(); @Override String getDescription(); @Override Operation operation(); @Override String path(); }### Answer: @Test void operationType() { NestedDelete NestedDelete = new NestedDelete(metaResource, metaResourceField, relatedMetaResource); Assert.assertEquals(OperationType.DELETE, NestedDelete.operationType()); }
### Question: NestedDelete extends AbstractNestedDeleteOperation implements OASOperation { @Override public boolean isEnabled() { return metaResource.isReadable() && metaResourceField.isUpdatable(); } NestedDelete(MetaResource metaResource, MetaResourceField metaResourceField, MetaResource relatedMetaResource); @Override OperationType operationType(); @Override boolean isEnabled(); @Override String getDescription(); @Override Operation operation(); @Override String path(); }### Answer: @Test void isEnabledTrueWhenReadableAndFieldUpdatable() { NestedDelete NestedDelete = new NestedDelete(metaResource, metaResourceField, relatedMetaResource); Assert.assertTrue(metaResource.isReadable()); metaResourceField.setUpdatable(true); Assert.assertTrue(NestedDelete.isEnabled()); } @Test void isEnabledFalseWhenReadableAndFieldNotUpdatable() { NestedDelete NestedDelete = new NestedDelete(metaResource, metaResourceField, relatedMetaResource); Assert.assertTrue(metaResource.isReadable()); metaResource.setUpdatable(false); Assert.assertFalse(NestedDelete.isEnabled()); } @Test void isEnabledFalseWhenNotReadableAndFieldUpdatable() { NestedDelete NestedDelete = new NestedDelete(metaResource, metaResourceField, relatedMetaResource); metaResource.setReadable(false); metaResourceField.setUpdatable(true); Assert.assertFalse(NestedDelete.isEnabled()); } @Test void isEnabledFalseWhenNotReadableAndFieldNotUpdatable() { NestedDelete NestedDelete = new NestedDelete(metaResource, metaResourceField, relatedMetaResource); metaResource.setReadable(false); metaResourceField.setUpdatable(false); Assert.assertFalse(NestedDelete.isEnabled()); }
### Question: NestedDelete extends AbstractNestedDeleteOperation implements OASOperation { @Override public String getDescription() { return "Delete " + metaResource.getResourceType() + " relationship to a " + relatedMetaResource.getResourceType() + " resource"; } NestedDelete(MetaResource metaResource, MetaResourceField metaResourceField, MetaResource relatedMetaResource); @Override OperationType operationType(); @Override boolean isEnabled(); @Override String getDescription(); @Override Operation operation(); @Override String path(); }### Answer: @Test void getDescription() { NestedDelete NestedDelete = new NestedDelete(metaResource, metaResourceField, relatedMetaResource); Assert.assertEquals("Delete ResourceType relationship to a RelatedResourceType resource", NestedDelete.getDescription()); }
### Question: NestedDelete extends AbstractNestedDeleteOperation implements OASOperation { @Override public Operation operation() { Operation operation = super.operation(); ApiResponse responseSchema = OASUtils.oneToMany(metaResourceField) ? new ResourceReferencesResponse(relatedMetaResource).$ref() : new ResourceReferenceResponse(relatedMetaResource).$ref(); responses.put("200", responseSchema); return operation.responses(apiResponsesFromMap(responses)); } NestedDelete(MetaResource metaResource, MetaResourceField metaResourceField, MetaResource relatedMetaResource); @Override OperationType operationType(); @Override boolean isEnabled(); @Override String getDescription(); @Override Operation operation(); @Override String path(); }### Answer: @Test void operation() { Operation operation = new NestedDelete(metaResource, metaResourceField, relatedMetaResource).operation(); Assert.assertTrue(operation.getResponses().containsKey("200")); }
### Question: NestedDelete extends AbstractNestedDeleteOperation implements OASOperation { @Override public String path() { return OASUtils.getNestedPath(metaResource, metaResourceField); } NestedDelete(MetaResource metaResource, MetaResourceField metaResourceField, MetaResource relatedMetaResource); @Override OperationType operationType(); @Override boolean isEnabled(); @Override String getDescription(); @Override Operation operation(); @Override String path(); }### Answer: @Test void path() { NestedDelete NestedDelete = new NestedDelete(metaResource, metaResourceField, relatedMetaResource); Assert.assertEquals("/ResourcePath/{id}/someRelatedResource", NestedDelete.path()); }
### Question: ResourcePatch extends AbstractResourceOperation implements OASOperation { @Override public OperationType operationType() { return operationType; } ResourcePatch(MetaResource metaResource); @Override OperationType operationType(); @Override boolean isEnabled(); @Override String getDescription(); @Override Operation operation(); @Override String path(); static final OperationType operationType; }### Answer: @Test void operationType() { ResourcePatch resourcePost = new ResourcePatch(metaResource); Assert.assertEquals(OperationType.PATCH, resourcePost.operationType()); }
### Question: ResourcePatch extends AbstractResourceOperation implements OASOperation { @Override public boolean isEnabled() { return metaResource.isUpdatable(); } ResourcePatch(MetaResource metaResource); @Override OperationType operationType(); @Override boolean isEnabled(); @Override String getDescription(); @Override Operation operation(); @Override String path(); static final OperationType operationType; }### Answer: @Test void isEnabledTrueWhenUpdateable() { ResourcePatch resourcePost = new ResourcePatch(metaResource); Assert.assertTrue(metaResource.isUpdatable()); Assert.assertTrue(resourcePost.isEnabled()); } @Test void isEnabled() { ResourcePatch resourcePost = new ResourcePatch(metaResource); metaResource.setUpdatable(false); Assert.assertFalse(resourcePost.isEnabled()); }
### Question: ResourcePatch extends AbstractResourceOperation implements OASOperation { @Override public String getDescription() { return "Update a " + metaResource.getName(); } ResourcePatch(MetaResource metaResource); @Override OperationType operationType(); @Override boolean isEnabled(); @Override String getDescription(); @Override Operation operation(); @Override String path(); static final OperationType operationType; }### Answer: @Test void getDescription() { ResourcePatch resourcePost = new ResourcePatch(metaResource); Assert.assertEquals("Update a ResourceName", resourcePost.getDescription()); }
### Question: ResourcePatch extends AbstractResourceOperation implements OASOperation { @Override public Operation operation() { Operation operation = super.operation(); operation.addParametersItem(new PrimaryKey(metaResource).$ref()); operation.setRequestBody( new RequestBody() .content( new Content() .addMediaType("application/vnd.api+json", new MediaType() .schema(new PatchResource(metaResource).$ref())))); responses.put("200", new ApiResponse() .description("OK") .content(new Content() .addMediaType("application/vnd.api+json", new MediaType().schema(new Info().$ref())))); return operation.responses(apiResponsesFromMap(responses)); } ResourcePatch(MetaResource metaResource); @Override OperationType operationType(); @Override boolean isEnabled(); @Override String getDescription(); @Override Operation operation(); @Override String path(); static final OperationType operationType; }### Answer: @Test void operation() { Operation operation = new ResourcePatch(metaResource).operation(); Assert.assertTrue(operation.getResponses().containsKey("200")); }
### Question: ResourcePatch extends AbstractResourceOperation implements OASOperation { @Override public String path() { return OASUtils.getResourcePath(metaResource); } ResourcePatch(MetaResource metaResource); @Override OperationType operationType(); @Override boolean isEnabled(); @Override String getDescription(); @Override Operation operation(); @Override String path(); static final OperationType operationType; }### Answer: @Test void path() { ResourcePatch resourcePost = new ResourcePatch(metaResource); Assert.assertEquals("/ResourcePath/{id}", resourcePost.path()); }
### Question: ResourcesPost extends AbstractResourceOperation implements OASOperation { @Override public OperationType operationType() { return operationType; } ResourcesPost(MetaResource metaResource); @Override OperationType operationType(); @Override boolean isEnabled(); @Override String getDescription(); @Override Operation operation(); @Override String path(); static final OperationType operationType; }### Answer: @Test void operationType() { ResourcesPost resourcePost = new ResourcesPost(metaResource); Assert.assertEquals(OperationType.POST, resourcePost.operationType()); }
### Question: ResourcesPost extends AbstractResourceOperation implements OASOperation { @Override public boolean isEnabled() { return metaResource.isInsertable(); } ResourcesPost(MetaResource metaResource); @Override OperationType operationType(); @Override boolean isEnabled(); @Override String getDescription(); @Override Operation operation(); @Override String path(); static final OperationType operationType; }### Answer: @Test void isEnabledTrueWhenInsertable() { ResourcesPost resourcePost = new ResourcesPost(metaResource); Assert.assertTrue(metaResource.isInsertable()); Assert.assertTrue(resourcePost.isEnabled()); } @Test void isEnabled() { ResourcesPost resourcePost = new ResourcesPost(metaResource); metaResource.setInsertable(false); Assert.assertFalse(resourcePost.isEnabled()); }
### Question: ResourcesPost extends AbstractResourceOperation implements OASOperation { @Override public String getDescription() { if (metaResource.getRepository().isBulk()) { return "Create one (or more) " + metaResource.getName(); } return "Create a " + metaResource.getName(); } ResourcesPost(MetaResource metaResource); @Override OperationType operationType(); @Override boolean isEnabled(); @Override String getDescription(); @Override Operation operation(); @Override String path(); static final OperationType operationType; }### Answer: @Test void getDescription() { ResourcesPost resourcePost = new ResourcesPost(metaResource); Assert.assertEquals("Create a ResourceName", resourcePost.getDescription()); } @Test void getDescriptionWhenRepositoryIsBulk() { metaResource.getRepository().setBulk(true); ResourcesPost resourcePost = new ResourcesPost(metaResource); Assert.assertEquals("Create one (or more) ResourceName", resourcePost.getDescription()); }
### Question: ResourcesPost extends AbstractResourceOperation implements OASOperation { @Override public Operation operation() { Operation operation = super.operation(); Schema requestSchema = new PostResource(metaResource).$ref(); Schema responseSchema = new ResourceResponseSchema(metaResource).$ref(); if (metaResource.getRepository().isBulk()) { requestSchema = new ComposedSchema() .oneOf( Arrays.asList( new PostResource(metaResource).$ref(), new PostResources(metaResource).$ref())); responseSchema = new ComposedSchema() .oneOf( Arrays.asList( new ResourceResponseSchema(metaResource).$ref(), new ResourcesResponseSchema(metaResource).$ref())); } operation.setRequestBody( new RequestBody() .content( new Content() .addMediaType( "application/vnd.api+json", new MediaType() .schema(requestSchema)))); responses.put("201", new ApiResponse() .description("Created") .content(new Content() .addMediaType("application/vnd.api+json", new MediaType().schema(responseSchema)))); return operation.responses(apiResponsesFromMap(responses)); } ResourcesPost(MetaResource metaResource); @Override OperationType operationType(); @Override boolean isEnabled(); @Override String getDescription(); @Override Operation operation(); @Override String path(); static final OperationType operationType; }### Answer: @Test void operation() { Operation operation = new ResourcesPost(metaResource).operation(); Assert.assertTrue(operation.getResponses().containsKey("201")); }
### Question: ResourcesPost extends AbstractResourceOperation implements OASOperation { @Override public String path() { return OASUtils.getResourcesPath(metaResource); } ResourcesPost(MetaResource metaResource); @Override OperationType operationType(); @Override boolean isEnabled(); @Override String getDescription(); @Override Operation operation(); @Override String path(); static final OperationType operationType; }### Answer: @Test void path() { ResourcesPost resourcePost = new ResourcesPost(metaResource); Assert.assertEquals("/ResourcePath", resourcePost.path()); }
### Question: ResourceGet extends AbstractResourceOperation implements OASOperation { @Override public OperationType operationType() { return operationType; } ResourceGet(MetaResource metaResource); @Override OperationType operationType(); @Override boolean isEnabled(); @Override String getDescription(); @Override Operation operation(); @Override String path(); static final OperationType operationType; }### Answer: @Test void operationType() { ResourceGet resourcePost = new ResourceGet(metaResource); Assert.assertEquals(OperationType.GET, resourcePost.operationType()); }
### Question: ResourceGet extends AbstractResourceOperation implements OASOperation { @Override public boolean isEnabled() { return metaResource.isReadable(); } ResourceGet(MetaResource metaResource); @Override OperationType operationType(); @Override boolean isEnabled(); @Override String getDescription(); @Override Operation operation(); @Override String path(); static final OperationType operationType; }### Answer: @Test void isEnabledTrueWhenReadable() { ResourceGet resourcePost = new ResourceGet(metaResource); Assert.assertTrue(metaResource.isReadable()); Assert.assertTrue(resourcePost.isEnabled()); } @Test void isEnabled() { ResourceGet resourcePost = new ResourceGet(metaResource); metaResource.setReadable(false); Assert.assertFalse(resourcePost.isEnabled()); }
### Question: ResourceGet extends AbstractResourceOperation implements OASOperation { @Override public String getDescription() { return "Retrieve a " + metaResource.getResourceType() + " resource"; } ResourceGet(MetaResource metaResource); @Override OperationType operationType(); @Override boolean isEnabled(); @Override String getDescription(); @Override Operation operation(); @Override String path(); static final OperationType operationType; }### Answer: @Test void getDescription() { ResourceGet resourcePost = new ResourceGet(metaResource); Assert.assertEquals("Retrieve a ResourceType resource", resourcePost.getDescription()); }
### Question: ResourceGet extends AbstractResourceOperation implements OASOperation { @Override public Operation operation() { Operation operation = super.operation(); operation.addParametersItem(new PrimaryKey(metaResource).$ref()); operation.addParametersItem(new Fields(metaResource).$ref()); operation.addParametersItem(new Include(metaResource).$ref()); responses.put("200", new ResourceResponse(metaResource).$ref()); return operation.responses(apiResponsesFromMap(responses)); } ResourceGet(MetaResource metaResource); @Override OperationType operationType(); @Override boolean isEnabled(); @Override String getDescription(); @Override Operation operation(); @Override String path(); static final OperationType operationType; }### Answer: @Test void operation() { Operation operation = new ResourceGet(metaResource).operation(); Assert.assertTrue(operation.getResponses().containsKey("200")); }
### Question: ResourceGet extends AbstractResourceOperation implements OASOperation { @Override public String path() { return OASUtils.getResourcePath(metaResource); } ResourceGet(MetaResource metaResource); @Override OperationType operationType(); @Override boolean isEnabled(); @Override String getDescription(); @Override Operation operation(); @Override String path(); static final OperationType operationType; }### Answer: @Test void path() { ResourceGet resourcePost = new ResourceGet(metaResource); Assert.assertEquals("/ResourcePath/{id}", resourcePost.path()); }
### Question: ResourceDelete extends AbstractResourceOperation implements OASOperation { @Override public OperationType operationType() { return operationType; } ResourceDelete(MetaResource metaResource); @Override OperationType operationType(); @Override boolean isEnabled(); @Override String getDescription(); @Override Operation operation(); @Override String path(); static final OperationType operationType; }### Answer: @Test void operationType() { ResourceDelete ResourceDelete = new ResourceDelete(metaResource); Assert.assertEquals(OperationType.DELETE, ResourceDelete.operationType()); }
### Question: ResourceDelete extends AbstractResourceOperation implements OASOperation { @Override public boolean isEnabled() { return metaResource.isDeletable(); } ResourceDelete(MetaResource metaResource); @Override OperationType operationType(); @Override boolean isEnabled(); @Override String getDescription(); @Override Operation operation(); @Override String path(); static final OperationType operationType; }### Answer: @Test void isEnabledTrueWhenDeletable() { ResourceDelete ResourceDelete = new ResourceDelete(metaResource); Assert.assertTrue(metaResource.isDeletable()); Assert.assertTrue(ResourceDelete.isEnabled()); } @Test void isEnabled() { ResourceDelete ResourceDelete = new ResourceDelete(metaResource); metaResource.setDeletable(false); Assert.assertFalse(ResourceDelete.isEnabled()); }
### Question: ResourceDelete extends AbstractResourceOperation implements OASOperation { @Override public String getDescription() { return "Delete a " + metaResource.getName(); } ResourceDelete(MetaResource metaResource); @Override OperationType operationType(); @Override boolean isEnabled(); @Override String getDescription(); @Override Operation operation(); @Override String path(); static final OperationType operationType; }### Answer: @Test void getDescription() { ResourceDelete ResourceDelete = new ResourceDelete(metaResource); Assert.assertEquals("Delete a ResourceName", ResourceDelete.getDescription()); }
### Question: ResourceDelete extends AbstractResourceOperation implements OASOperation { @Override public Operation operation() { Operation operation = super.operation(); operation.addParametersItem(new PrimaryKey(metaResource).$ref()); responses.put("200", new ApiResponse().description("OK")); return operation.responses(apiResponsesFromMap(responses)); } ResourceDelete(MetaResource metaResource); @Override OperationType operationType(); @Override boolean isEnabled(); @Override String getDescription(); @Override Operation operation(); @Override String path(); static final OperationType operationType; }### Answer: @Test void operation() { Operation operation = new ResourceDelete(metaResource).operation(); Assert.assertTrue(operation.getResponses().containsKey("200")); }
### Question: ResourceDelete extends AbstractResourceOperation implements OASOperation { @Override public String path() { return OASUtils.getResourcePath(metaResource); } ResourceDelete(MetaResource metaResource); @Override OperationType operationType(); @Override boolean isEnabled(); @Override String getDescription(); @Override Operation operation(); @Override String path(); static final OperationType operationType; }### Answer: @Test void path() { ResourceDelete ResourceDelete = new ResourceDelete(metaResource); Assert.assertEquals("/ResourcePath/{id}", ResourceDelete.path()); }
### Question: RelationshipGet extends AbstractNestedAccessOperation implements OASOperation { @Override public OperationType operationType() { return operationType; } RelationshipGet(MetaResource metaResource, MetaResourceField metaResourceField, MetaResource relatedMetaResource); @Override OperationType operationType(); @Override boolean isEnabled(); @Override String getDescription(); @Override Operation operation(); @Override String path(); }### Answer: @Test void operationType() { RelationshipGet RelationshipGet = new RelationshipGet(metaResource, metaResourceField, relatedMetaResource); Assert.assertEquals(OperationType.GET, RelationshipGet.operationType()); }
### Question: RelationshipGet extends AbstractNestedAccessOperation implements OASOperation { @Override public boolean isEnabled() { return metaResource.isReadable() && metaResourceField.isReadable(); } RelationshipGet(MetaResource metaResource, MetaResourceField metaResourceField, MetaResource relatedMetaResource); @Override OperationType operationType(); @Override boolean isEnabled(); @Override String getDescription(); @Override Operation operation(); @Override String path(); }### Answer: @Test void isEnabledTrueWhenReadableAndFieldReadable() { RelationshipGet RelationshipGet = new RelationshipGet(metaResource, metaResourceField, relatedMetaResource); Assert.assertTrue(metaResource.isReadable()); metaResourceField.setReadable(true); Assert.assertTrue(RelationshipGet.isEnabled()); } @Test void isEnabledFalseWhenReadableAndFieldNotReadable() { RelationshipGet RelationshipGet = new RelationshipGet(metaResource, metaResourceField, relatedMetaResource); Assert.assertTrue(metaResource.isReadable()); metaResource.setReadable(false); Assert.assertFalse(RelationshipGet.isEnabled()); } @Test void isEnabledFalseWhenNotReadableAndFieldReadable() { RelationshipGet RelationshipGet = new RelationshipGet(metaResource, metaResourceField, relatedMetaResource); metaResource.setReadable(false); metaResourceField.setReadable(true); Assert.assertFalse(RelationshipGet.isEnabled()); } @Test void isEnabledFalseWhenNotReadableAndFieldNotReadable() { RelationshipGet RelationshipGet = new RelationshipGet(metaResource, metaResourceField, relatedMetaResource); metaResource.setReadable(false); metaResourceField.setReadable(false); Assert.assertFalse(RelationshipGet.isEnabled()); }
### Question: RelationshipGet extends AbstractNestedAccessOperation implements OASOperation { @Override public String getDescription() { return "Retrieve " + relatedMetaResource.getResourceType() + " references related to a " + metaResource.getResourceType() + " resource"; } RelationshipGet(MetaResource metaResource, MetaResourceField metaResourceField, MetaResource relatedMetaResource); @Override OperationType operationType(); @Override boolean isEnabled(); @Override String getDescription(); @Override Operation operation(); @Override String path(); }### Answer: @Test void getDescription() { RelationshipGet RelationshipGet = new RelationshipGet(metaResource, metaResourceField, relatedMetaResource); Assert.assertEquals("Retrieve RelatedResourceType references related to a ResourceType resource", RelationshipGet.getDescription()); }
### Question: RelationshipGet extends AbstractNestedAccessOperation implements OASOperation { @Override public Operation operation() { Operation operation = super.operation(); ApiResponse responseSchema = OASUtils.oneToMany(metaResourceField) ? new ResourceReferencesResponse(relatedMetaResource).$ref() : new ResourceReferenceResponse(relatedMetaResource).$ref(); responses.put("200", responseSchema); return operation.responses(apiResponsesFromMap(responses)); } RelationshipGet(MetaResource metaResource, MetaResourceField metaResourceField, MetaResource relatedMetaResource); @Override OperationType operationType(); @Override boolean isEnabled(); @Override String getDescription(); @Override Operation operation(); @Override String path(); }### Answer: @Test void operation() { Operation operation = new RelationshipGet(metaResource, metaResourceField, relatedMetaResource).operation(); Assert.assertTrue(operation.getResponses().containsKey("200")); }
### Question: RelationshipGet extends AbstractNestedAccessOperation implements OASOperation { @Override public String path() { return OASUtils.getRelationshipsPath(metaResource, metaResourceField); } RelationshipGet(MetaResource metaResource, MetaResourceField metaResourceField, MetaResource relatedMetaResource); @Override OperationType operationType(); @Override boolean isEnabled(); @Override String getDescription(); @Override Operation operation(); @Override String path(); }### Answer: @Test void path() { RelationshipGet RelationshipGet = new RelationshipGet(metaResource, metaResourceField, relatedMetaResource); Assert.assertEquals("/ResourcePath/{id}/relationships/someRelatedResource", RelationshipGet.path()); }
### Question: RelationshipDelete extends AbstractNestedDeleteOperation implements OASOperation { @Override public OperationType operationType() { return operationType; } RelationshipDelete(MetaResource metaResource, MetaResourceField metaResourceField, MetaResource relatedMetaResource); @Override OperationType operationType(); @Override boolean isEnabled(); @Override String getDescription(); @Override Operation operation(); @Override String path(); }### Answer: @Test void operationType() { RelationshipDelete RelationshipDelete = new RelationshipDelete(metaResource, metaResourceField, relatedMetaResource); Assert.assertEquals(OperationType.DELETE, RelationshipDelete.operationType()); }
### Question: RelationshipDelete extends AbstractNestedDeleteOperation implements OASOperation { @Override public boolean isEnabled() { return metaResource.isReadable() && metaResourceField.isUpdatable(); } RelationshipDelete(MetaResource metaResource, MetaResourceField metaResourceField, MetaResource relatedMetaResource); @Override OperationType operationType(); @Override boolean isEnabled(); @Override String getDescription(); @Override Operation operation(); @Override String path(); }### Answer: @Test void isEnabledTrueWhenReadableAndFieldUpdatable() { RelationshipDelete RelationshipDelete = new RelationshipDelete(metaResource, metaResourceField, relatedMetaResource); Assert.assertTrue(metaResource.isReadable()); metaResourceField.setUpdatable(true); Assert.assertTrue(RelationshipDelete.isEnabled()); } @Test void isEnabledFalseWhenReadableAndFieldNotUpdatable() { RelationshipDelete RelationshipDelete = new RelationshipDelete(metaResource, metaResourceField, relatedMetaResource); Assert.assertTrue(metaResource.isReadable()); metaResource.setUpdatable(false); Assert.assertFalse(RelationshipDelete.isEnabled()); } @Test void isEnabledFalseWhenNotReadableAndFieldUpdatable() { RelationshipDelete RelationshipDelete = new RelationshipDelete(metaResource, metaResourceField, relatedMetaResource); metaResource.setReadable(false); metaResourceField.setUpdatable(true); Assert.assertFalse(RelationshipDelete.isEnabled()); } @Test void isEnabledFalseWhenNotReadableAndFieldNotUpdatable() { RelationshipDelete RelationshipDelete = new RelationshipDelete(metaResource, metaResourceField, relatedMetaResource); metaResource.setReadable(false); metaResourceField.setUpdatable(false); Assert.assertFalse(RelationshipDelete.isEnabled()); }
### Question: RelationshipDelete extends AbstractNestedDeleteOperation implements OASOperation { @Override public String getDescription() { return "Delete " + metaResource.getResourceType() + " relationship to a " + relatedMetaResource.getResourceType() + " resource"; } RelationshipDelete(MetaResource metaResource, MetaResourceField metaResourceField, MetaResource relatedMetaResource); @Override OperationType operationType(); @Override boolean isEnabled(); @Override String getDescription(); @Override Operation operation(); @Override String path(); }### Answer: @Test void getDescription() { RelationshipDelete RelationshipDelete = new RelationshipDelete(metaResource, metaResourceField, relatedMetaResource); Assert.assertEquals("Delete ResourceType relationship to a RelatedResourceType resource", RelationshipDelete.getDescription()); }
### Question: RelationshipDelete extends AbstractNestedDeleteOperation implements OASOperation { @Override public Operation operation() { Operation operation = super.operation(); ApiResponse responseSchema = OASUtils.oneToMany(metaResourceField) ? new ResourceReferencesResponse(relatedMetaResource).$ref() : new ResourceReferenceResponse(relatedMetaResource).$ref(); responses.put("200", responseSchema); return operation.responses(apiResponsesFromMap(responses)); } RelationshipDelete(MetaResource metaResource, MetaResourceField metaResourceField, MetaResource relatedMetaResource); @Override OperationType operationType(); @Override boolean isEnabled(); @Override String getDescription(); @Override Operation operation(); @Override String path(); }### Answer: @Test void operation() { Operation operation = new RelationshipDelete(metaResource, metaResourceField, relatedMetaResource).operation(); Assert.assertTrue(operation.getResponses().containsKey("200")); }
### Question: RelationshipDelete extends AbstractNestedDeleteOperation implements OASOperation { @Override public String path() { return OASUtils.getRelationshipsPath(metaResource, metaResourceField); } RelationshipDelete(MetaResource metaResource, MetaResourceField metaResourceField, MetaResource relatedMetaResource); @Override OperationType operationType(); @Override boolean isEnabled(); @Override String getDescription(); @Override Operation operation(); @Override String path(); }### Answer: @Test void path() { RelationshipDelete RelationshipDelete = new RelationshipDelete(metaResource, metaResourceField, relatedMetaResource); Assert.assertEquals("/ResourcePath/{id}/relationships/someRelatedResource", RelationshipDelete.path()); }
### Question: NestedGet extends AbstractNestedAccessOperation implements OASOperation { @Override public OperationType operationType() { return operationType; } NestedGet(MetaResource metaResource, MetaResourceField metaResourceField, MetaResource relatedMetaResource); @Override OperationType operationType(); @Override boolean isEnabled(); @Override String getDescription(); @Override Operation operation(); @Override String path(); }### Answer: @Test void operationType() { NestedGet NestedGet = new NestedGet(metaResource, metaResourceField, relatedMetaResource); Assert.assertEquals(OperationType.GET, NestedGet.operationType()); }
### Question: NestedGet extends AbstractNestedAccessOperation implements OASOperation { @Override public boolean isEnabled() { return metaResource.isReadable() && metaResourceField.isReadable(); } NestedGet(MetaResource metaResource, MetaResourceField metaResourceField, MetaResource relatedMetaResource); @Override OperationType operationType(); @Override boolean isEnabled(); @Override String getDescription(); @Override Operation operation(); @Override String path(); }### Answer: @Test void isEnabledTrueWhenReadableAndFieldReadable() { NestedGet NestedGet = new NestedGet(metaResource, metaResourceField, relatedMetaResource); Assert.assertTrue(metaResource.isReadable()); metaResourceField.setReadable(true); Assert.assertTrue(NestedGet.isEnabled()); } @Test void isEnabledFalseWhenReadableAndFieldNotReadable() { NestedGet NestedGet = new NestedGet(metaResource, metaResourceField, relatedMetaResource); Assert.assertTrue(metaResource.isReadable()); metaResource.setReadable(false); Assert.assertFalse(NestedGet.isEnabled()); } @Test void isEnabledFalseWhenNotReadableAndFieldReadable() { NestedGet NestedGet = new NestedGet(metaResource, metaResourceField, relatedMetaResource); metaResource.setReadable(false); metaResourceField.setReadable(true); Assert.assertFalse(NestedGet.isEnabled()); } @Test void isEnabledFalseWhenNotReadableAndFieldNotReadable() { NestedGet NestedGet = new NestedGet(metaResource, metaResourceField, relatedMetaResource); metaResource.setReadable(false); metaResourceField.setReadable(false); Assert.assertFalse(NestedGet.isEnabled()); }
### Question: NestedGet extends AbstractNestedAccessOperation implements OASOperation { @Override public String getDescription() { return "Retrieve " + relatedMetaResource.getResourceType() + " related to a " + metaResource.getResourceType() + " resource"; } NestedGet(MetaResource metaResource, MetaResourceField metaResourceField, MetaResource relatedMetaResource); @Override OperationType operationType(); @Override boolean isEnabled(); @Override String getDescription(); @Override Operation operation(); @Override String path(); }### Answer: @Test void getDescription() { NestedGet NestedGet = new NestedGet(metaResource, metaResourceField, relatedMetaResource); Assert.assertEquals("Retrieve RelatedResourceType related to a ResourceType resource", NestedGet.getDescription()); }
### Question: NestedGet extends AbstractNestedAccessOperation implements OASOperation { @Override public Operation operation() { Operation operation = super.operation(); ApiResponse responseSchema = OASUtils.oneToMany(metaResourceField) ? new ResourcesResponse(relatedMetaResource).$ref() : new ResourceResponse(relatedMetaResource).$ref(); responses.put("200", responseSchema); return operation.responses(apiResponsesFromMap(responses)); } NestedGet(MetaResource metaResource, MetaResourceField metaResourceField, MetaResource relatedMetaResource); @Override OperationType operationType(); @Override boolean isEnabled(); @Override String getDescription(); @Override Operation operation(); @Override String path(); }### Answer: @Test void operation() { Operation operation = new NestedGet(metaResource, metaResourceField, relatedMetaResource).operation(); Assert.assertTrue(operation.getResponses().containsKey("200")); }
### Question: CrnkServlet extends HttpServlet { public CrnkBoot getBoot() { return boot; } @Override void init(); String getDefaultCharacterEncoding(); void setDefaultCharacterEncoding(String defaultCharacterEncoding); CrnkBoot getBoot(); }### Answer: @Test public void testGetBoot() { Assert.assertNotNull(servlet.getBoot()); }
### Question: NestedGet extends AbstractNestedAccessOperation implements OASOperation { @Override public String path() { return OASUtils.getNestedPath(metaResource, metaResourceField); } NestedGet(MetaResource metaResource, MetaResourceField metaResourceField, MetaResource relatedMetaResource); @Override OperationType operationType(); @Override boolean isEnabled(); @Override String getDescription(); @Override Operation operation(); @Override String path(); }### Answer: @Test void path() { NestedGet NestedGet = new NestedGet(metaResource, metaResourceField, relatedMetaResource); Assert.assertEquals("/ResourcePath/{id}/someRelatedResource", NestedGet.path()); }

Subsets and Splits

No community queries yet

The top public SQL queries from the community will appear here once available.