method2testcases
stringlengths 118
6.63k
|
|---|
### Question:
EntityRepositoryHibernate implements EntityRepository { @Override public String getQueryStringOfNamedQuery(String queryName) { Query query = getSession().getNamedQuery(queryName); return query.getQueryString(); } EntityRepositoryHibernate(); EntityRepositoryHibernate(SessionFactory sessionFactory); EntityRepositoryHibernate(Session session); @Override T save(T entity); @Override void remove(Entity entity); @Override boolean exists(final Class<T> clazz, final Serializable id); @Override T get(final Class<T> clazz, final Serializable id); @Override T load(final Class<T> clazz, final Serializable id); @Override T getUnmodified(Class<T> clazz, T entity); @Override T getByBusinessKeys(Class<T> clazz, NamedParameters keyValues); @Override List<T> findAll(Class<T> clazz); @Override CriteriaQuery createCriteriaQuery(Class<T> entityClass); @SuppressWarnings("rawtypes") @Override List<T> find(CriteriaQuery criteriaQuery); @Override T getSingleResult(CriteriaQuery criteriaQuery); @Override List<T> find(Class<T> entityClass, QueryCriterion criterion); @Override T getSingleResult(Class<T> entityClass, QueryCriterion criterion); @Override JpqlQuery createJpqlQuery(String jpql); @Override List<T> find(JpqlQuery jpqlQuery); @Override T getSingleResult(JpqlQuery jpqlQuery); @Override int executeUpdate(JpqlQuery jpqlQuery); @Override NamedQuery createNamedQuery(String queryName); @Override List<T> find(NamedQuery namedQuery); @Override T getSingleResult(NamedQuery namedQuery); @Override int executeUpdate(NamedQuery namedQuery); @Override SqlQuery createSqlQuery(String sql); @SuppressWarnings("rawtypes") @Override List<T> find(SqlQuery sqlQuery); @Override T getSingleResult(SqlQuery sqlQuery); @Override int executeUpdate(SqlQuery sqlQuery); @Override List<T> findByExample(final E example, final ExampleSettings<T> settings); @Override List<T> findByProperty(Class<T> clazz, String propertyName, Object propertyValue); @Override List<T> findByProperties(Class<T> clazz, NamedParameters properties); @Override String getQueryStringOfNamedQuery(String queryName); @Override void flush(); @Override void refresh(Entity entity); @Override void clear(); }### Answer:
@Test public void testGetQueryStringOfNamedQuery() { assertEquals("select o.code, o.text from Dictionary o where o.category = :category", repository.getQueryStringOfNamedQuery("Dictionay.findNameAndOrder")); } |
### Question:
EntityRepositoryHibernate implements EntityRepository { @Override public void flush() { getSession().flush(); } EntityRepositoryHibernate(); EntityRepositoryHibernate(SessionFactory sessionFactory); EntityRepositoryHibernate(Session session); @Override T save(T entity); @Override void remove(Entity entity); @Override boolean exists(final Class<T> clazz, final Serializable id); @Override T get(final Class<T> clazz, final Serializable id); @Override T load(final Class<T> clazz, final Serializable id); @Override T getUnmodified(Class<T> clazz, T entity); @Override T getByBusinessKeys(Class<T> clazz, NamedParameters keyValues); @Override List<T> findAll(Class<T> clazz); @Override CriteriaQuery createCriteriaQuery(Class<T> entityClass); @SuppressWarnings("rawtypes") @Override List<T> find(CriteriaQuery criteriaQuery); @Override T getSingleResult(CriteriaQuery criteriaQuery); @Override List<T> find(Class<T> entityClass, QueryCriterion criterion); @Override T getSingleResult(Class<T> entityClass, QueryCriterion criterion); @Override JpqlQuery createJpqlQuery(String jpql); @Override List<T> find(JpqlQuery jpqlQuery); @Override T getSingleResult(JpqlQuery jpqlQuery); @Override int executeUpdate(JpqlQuery jpqlQuery); @Override NamedQuery createNamedQuery(String queryName); @Override List<T> find(NamedQuery namedQuery); @Override T getSingleResult(NamedQuery namedQuery); @Override int executeUpdate(NamedQuery namedQuery); @Override SqlQuery createSqlQuery(String sql); @SuppressWarnings("rawtypes") @Override List<T> find(SqlQuery sqlQuery); @Override T getSingleResult(SqlQuery sqlQuery); @Override int executeUpdate(SqlQuery sqlQuery); @Override List<T> findByExample(final E example, final ExampleSettings<T> settings); @Override List<T> findByProperty(Class<T> clazz, String propertyName, Object propertyValue); @Override List<T> findByProperties(Class<T> clazz, NamedParameters properties); @Override String getQueryStringOfNamedQuery(String queryName); @Override void flush(); @Override void refresh(Entity entity); @Override void clear(); }### Answer:
@Test public void testFlush() { String description = "Ha Ha Ha!"; male.setDescription(description); repository.flush(); Dictionary male1 = repository.get(Dictionary.class, male.getId()); assertEquals(description, male1.getDescription()); } |
### Question:
EntityRepositoryHibernate implements EntityRepository { @Override public void refresh(Entity entity) { getSession().refresh(entity); } EntityRepositoryHibernate(); EntityRepositoryHibernate(SessionFactory sessionFactory); EntityRepositoryHibernate(Session session); @Override T save(T entity); @Override void remove(Entity entity); @Override boolean exists(final Class<T> clazz, final Serializable id); @Override T get(final Class<T> clazz, final Serializable id); @Override T load(final Class<T> clazz, final Serializable id); @Override T getUnmodified(Class<T> clazz, T entity); @Override T getByBusinessKeys(Class<T> clazz, NamedParameters keyValues); @Override List<T> findAll(Class<T> clazz); @Override CriteriaQuery createCriteriaQuery(Class<T> entityClass); @SuppressWarnings("rawtypes") @Override List<T> find(CriteriaQuery criteriaQuery); @Override T getSingleResult(CriteriaQuery criteriaQuery); @Override List<T> find(Class<T> entityClass, QueryCriterion criterion); @Override T getSingleResult(Class<T> entityClass, QueryCriterion criterion); @Override JpqlQuery createJpqlQuery(String jpql); @Override List<T> find(JpqlQuery jpqlQuery); @Override T getSingleResult(JpqlQuery jpqlQuery); @Override int executeUpdate(JpqlQuery jpqlQuery); @Override NamedQuery createNamedQuery(String queryName); @Override List<T> find(NamedQuery namedQuery); @Override T getSingleResult(NamedQuery namedQuery); @Override int executeUpdate(NamedQuery namedQuery); @Override SqlQuery createSqlQuery(String sql); @SuppressWarnings("rawtypes") @Override List<T> find(SqlQuery sqlQuery); @Override T getSingleResult(SqlQuery sqlQuery); @Override int executeUpdate(SqlQuery sqlQuery); @Override List<T> findByExample(final E example, final ExampleSettings<T> settings); @Override List<T> findByProperty(Class<T> clazz, String propertyName, Object propertyValue); @Override List<T> findByProperties(Class<T> clazz, NamedParameters properties); @Override String getQueryStringOfNamedQuery(String queryName); @Override void flush(); @Override void refresh(Entity entity); @Override void clear(); }### Answer:
@Test public void testRefresh() { String text = "Ha Ha Ha!"; male.setText(text); repository.refresh(male); assertEquals("男", male.getText()); } |
### Question:
EntityRepositoryHibernate implements EntityRepository { @Override public void clear() { getSession().clear(); } EntityRepositoryHibernate(); EntityRepositoryHibernate(SessionFactory sessionFactory); EntityRepositoryHibernate(Session session); @Override T save(T entity); @Override void remove(Entity entity); @Override boolean exists(final Class<T> clazz, final Serializable id); @Override T get(final Class<T> clazz, final Serializable id); @Override T load(final Class<T> clazz, final Serializable id); @Override T getUnmodified(Class<T> clazz, T entity); @Override T getByBusinessKeys(Class<T> clazz, NamedParameters keyValues); @Override List<T> findAll(Class<T> clazz); @Override CriteriaQuery createCriteriaQuery(Class<T> entityClass); @SuppressWarnings("rawtypes") @Override List<T> find(CriteriaQuery criteriaQuery); @Override T getSingleResult(CriteriaQuery criteriaQuery); @Override List<T> find(Class<T> entityClass, QueryCriterion criterion); @Override T getSingleResult(Class<T> entityClass, QueryCriterion criterion); @Override JpqlQuery createJpqlQuery(String jpql); @Override List<T> find(JpqlQuery jpqlQuery); @Override T getSingleResult(JpqlQuery jpqlQuery); @Override int executeUpdate(JpqlQuery jpqlQuery); @Override NamedQuery createNamedQuery(String queryName); @Override List<T> find(NamedQuery namedQuery); @Override T getSingleResult(NamedQuery namedQuery); @Override int executeUpdate(NamedQuery namedQuery); @Override SqlQuery createSqlQuery(String sql); @SuppressWarnings("rawtypes") @Override List<T> find(SqlQuery sqlQuery); @Override T getSingleResult(SqlQuery sqlQuery); @Override int executeUpdate(SqlQuery sqlQuery); @Override List<T> findByExample(final E example, final ExampleSettings<T> settings); @Override List<T> findByProperty(Class<T> clazz, String propertyName, Object propertyValue); @Override List<T> findByProperties(Class<T> clazz, NamedParameters properties); @Override String getQueryStringOfNamedQuery(String queryName); @Override void flush(); @Override void refresh(Entity entity); @Override void clear(); }### Answer:
@Test public void testClear() { repository.clear(); } |
### Question:
TapestryInstanceProvider implements InstanceProvider { @Override public <T> T getInstance(Class<T> beanType) { try { return registry.getService(beanType); } catch (RuntimeException e) { return null; } } TapestryInstanceProvider(Registry registry); TapestryInstanceProvider(Class<?>... modules); @Override T getInstance(Class<T> beanType); @Override T getInstance(Class<T> beanType, String beanName); @Override T getInstance(Class<T> beanType, Class<? extends Annotation> annotationType); @Override Set<T> getInstances(Class<T> beanType); void shutdown(); }### Answer:
@Test public void testConstructorFromModule() { Service1 service = getProvider().getInstance(Service1.class); assertEquals("MyService1", service.name()); } |
### Question:
GuiceInstanceProvider implements InstanceProvider { @Override public <T> T getInstance(Class<T> beanType) { try { return injector.getInstance(beanType); } catch (com.google.inject.ConfigurationException e) { return null; } } GuiceInstanceProvider(Module... modules); GuiceInstanceProvider(Injector injector); @Override T getInstance(Class<T> beanType); @Override T getInstance(Class<T> beanType, String beanName); @Override T getInstance(Class<T> beanType, Class<? extends Annotation> annotationType); @Override Set<T> getInstances(Class<T> beanType); }### Answer:
@Test public void testConstructorFromModule() { assertEquals("I am Service 1", getProvider().getInstance(Service1.class).sayHello()); }
@Test public void testConstructorFromInjector() { InstanceProvider provider = new GuiceInstanceProvider(createInjector()); assertEquals("I am Service 1", provider.getInstance(Service1.class).sayHello()); }
@Override @Test public void testGetInstanceWithAnnotation() { Service3 service = getProvider().getInstance(Service3.class, MyBindingAnnotation.class); assertNotNull(service); } |
### Question:
EntityRepositoryJpa implements EntityRepository { @Override public <T extends Entity> List<T> findAll(final Class<T> clazz) { String queryString = "select o from " + clazz.getName() + " as o"; return getEntityManager().createQuery(queryString).getResultList(); } EntityRepositoryJpa(); EntityRepositoryJpa(EntityManager entityManager); EntityRepositoryJpa(EntityManagerFactory entityManagerFactory); EntityRepositoryJpa(NamedQueryParser namedQueryParser, EntityManagerFactory entityManagerFactory); final void setNamedQueryParser(NamedQueryParser namedQueryParser); @Override T save(T entity); @Override void remove(Entity entity); @Override boolean exists(final Class<T> clazz,
final Serializable id); @Override T get(final Class<T> clazz, final Serializable id); @Override T load(final Class<T> clazz, final Serializable id); @Override T getUnmodified(final Class<T> clazz,
final T entity); @Override T getByBusinessKeys(Class<T> clazz, NamedParameters keyValues); @Override List<T> findAll(final Class<T> clazz); @Override CriteriaQuery createCriteriaQuery(Class<T> entityClass); @Override List<T> find(CriteriaQuery criteriaQuery); @Override T getSingleResult(CriteriaQuery criteriaQuery); @Override List<T> find(Class<T> entityClass, QueryCriterion criterion); @Override T getSingleResult(Class<T> entityClass, QueryCriterion criterion); @Override JpqlQuery createJpqlQuery(String jpql); @Override List<T> find(JpqlQuery jpqlQuery); @Override T getSingleResult(JpqlQuery jpqlQuery); @Override int executeUpdate(JpqlQuery jpqlQuery); @Override NamedQuery createNamedQuery(String queryName); @Override List<T> find(NamedQuery namedQuery); @Override T getSingleResult(NamedQuery namedQuery); @Override int executeUpdate(NamedQuery namedQuery); @Override SqlQuery createSqlQuery(String sql); @Override List<T> find(SqlQuery sqlQuery); @Override T getSingleResult(SqlQuery sqlQuery); @Override int executeUpdate(SqlQuery sqlQuery); @Override List<T> findByExample(
final E example, final ExampleSettings<T> settings); @Override List<T> findByProperty(Class<T> clazz, String propertyName, Object propertyValue); @Override List<T> findByProperties(Class<T> clazz, NamedParameters properties); @Override String getQueryStringOfNamedQuery(String queryName); @Override void flush(); @Override void refresh(Entity entity); @Override void clear(); }### Answer:
@Test public void testFindAll() { List<Dictionary> results = repository.findAll(Dictionary.class); assertTrue(results.containsAll(Arrays.asList(male, undergraduate, graduate, associate))); } |
### Question:
GuiceInstanceProvider implements InstanceProvider { @Override public <T> Set<T> getInstances(Class<T> beanType) { Map<Key<?>, Binding<?>> allBindings = injector.getAllBindings(); Set<T> results = new HashSet<T>(); for (Map.Entry<Key<?>, Binding<?>> entry : allBindings.entrySet()) { Key<?> key = entry.getKey(); System.out.println("Key: " + key.getTypeLiteral().getRawType()); if (beanType.isAssignableFrom(key.getTypeLiteral().getRawType())) { System.out.println("True"); results.add((T) entry.getValue().getProvider().get()); } } return results; } GuiceInstanceProvider(Module... modules); GuiceInstanceProvider(Injector injector); @Override T getInstance(Class<T> beanType); @Override T getInstance(Class<T> beanType, String beanName); @Override T getInstance(Class<T> beanType, Class<? extends Annotation> annotationType); @Override Set<T> getInstances(Class<T> beanType); }### Answer:
@Test public void testGetInstances() { List<Service> expected = Arrays.asList( new MyService1(), new MyService21(), new MyService22(), new MyService31() ); Set<Service> services = getProvider().getInstances(Service.class); assertTrue(services.containsAll(expected)); } |
### Question:
BaseEntity implements Entity { @Override public boolean existed() { Object id = getId(); if (id == null) { return false; } if (id instanceof Number && ((Number)id).intValue() == 0) { return false; } return getRepository().exists(getClass(), getId()); } @Override boolean existed(); @Override boolean notExisted(); static void setRepository(EntityRepository repository); String[] businessKeys(); @Override int hashCode(); @Override boolean equals(Object other); }### Answer:
@Test public void testExistedIdIsNull() { guangdong.setId(null); assertFalse(guangdong.existed()); }
@Test public void testExistedIdIsZero() { guangdong.setId(0); assertFalse(guangdong.existed()); }
@Test public void testExistedRepositoryNotFound() { guangdong.setId(3); when(repository.exists(Organization.class, 3)).thenReturn(false); assertFalse(guangdong.existed()); }
@Test public void testExistedRepositoryFound() { guangdong.setId(3); when(repository.exists(Company.class, 3)).thenReturn(true); assertTrue(guangdong.existed()); } |
### Question:
BaseEntity implements Entity { @Override public boolean notExisted() { return !existed(); } @Override boolean existed(); @Override boolean notExisted(); static void setRepository(EntityRepository repository); String[] businessKeys(); @Override int hashCode(); @Override boolean equals(Object other); }### Answer:
@Test public void testNotExistedIdIsNull() { guangdong.setId(null); assertTrue(guangdong.notExisted()); }
@Test public void testNotExistedIdIsZero() { guangdong.setId(0); assertTrue(guangdong.notExisted()); }
@Test public void testNotExistedRepositoryNotFound() { guangdong.setId(3); when(repository.exists(Company.class, 3)).thenReturn(false); assertTrue(guangdong.notExisted()); }
@Test public void testNotExistedRepositoryFound() { guangdong.setId(3); when(repository.exists(Company.class, 3)).thenReturn(true); assertFalse(guangdong.notExisted()); }
@Test public void testNotExisted() { guangdong.setId(null); assertTrue(guangdong.notExisted()); guangdong.setId(0); assertTrue(guangdong.notExisted()); guangdong.setId(3); when(repository.exists(Company.class, 3)).thenReturn(false); assertTrue(guangdong.notExisted()); reset(repository); when(repository.exists(Company.class, 3)).thenReturn(true); assertFalse(guangdong.notExisted()); } |
### Question:
EntityRepositoryJpa implements EntityRepository { @Override public <T extends Entity> CriteriaQuery createCriteriaQuery(Class<T> entityClass) { return new CriteriaQuery(this, entityClass); } EntityRepositoryJpa(); EntityRepositoryJpa(EntityManager entityManager); EntityRepositoryJpa(EntityManagerFactory entityManagerFactory); EntityRepositoryJpa(NamedQueryParser namedQueryParser, EntityManagerFactory entityManagerFactory); final void setNamedQueryParser(NamedQueryParser namedQueryParser); @Override T save(T entity); @Override void remove(Entity entity); @Override boolean exists(final Class<T> clazz,
final Serializable id); @Override T get(final Class<T> clazz, final Serializable id); @Override T load(final Class<T> clazz, final Serializable id); @Override T getUnmodified(final Class<T> clazz,
final T entity); @Override T getByBusinessKeys(Class<T> clazz, NamedParameters keyValues); @Override List<T> findAll(final Class<T> clazz); @Override CriteriaQuery createCriteriaQuery(Class<T> entityClass); @Override List<T> find(CriteriaQuery criteriaQuery); @Override T getSingleResult(CriteriaQuery criteriaQuery); @Override List<T> find(Class<T> entityClass, QueryCriterion criterion); @Override T getSingleResult(Class<T> entityClass, QueryCriterion criterion); @Override JpqlQuery createJpqlQuery(String jpql); @Override List<T> find(JpqlQuery jpqlQuery); @Override T getSingleResult(JpqlQuery jpqlQuery); @Override int executeUpdate(JpqlQuery jpqlQuery); @Override NamedQuery createNamedQuery(String queryName); @Override List<T> find(NamedQuery namedQuery); @Override T getSingleResult(NamedQuery namedQuery); @Override int executeUpdate(NamedQuery namedQuery); @Override SqlQuery createSqlQuery(String sql); @Override List<T> find(SqlQuery sqlQuery); @Override T getSingleResult(SqlQuery sqlQuery); @Override int executeUpdate(SqlQuery sqlQuery); @Override List<T> findByExample(
final E example, final ExampleSettings<T> settings); @Override List<T> findByProperty(Class<T> clazz, String propertyName, Object propertyValue); @Override List<T> findByProperties(Class<T> clazz, NamedParameters properties); @Override String getQueryStringOfNamedQuery(String queryName); @Override void flush(); @Override void refresh(Entity entity); @Override void clear(); }### Answer:
@Test public void testCreateCriteriaQuery() { CriteriaQuery query = repository.createCriteriaQuery(Dictionary.class); assertEquals(Dictionary.class, query.getEntityClass()); } |
### Question:
BaseEntity implements Entity { @Override public int hashCode() { HashCodeBuilder builder = new HashCodeBuilder(13, 37); if (businessKeys() == null || businessKeys().length == 0) { return builder.append(getId()).toHashCode(); } BeanUtils thisBeanUtils = new BeanUtils(this); for (String businessKey : businessKeys()) { builder = builder.append(thisBeanUtils.getPropValue(businessKey)); } return builder.toHashCode(); } @Override boolean existed(); @Override boolean notExisted(); static void setRepository(EntityRepository repository); String[] businessKeys(); @Override int hashCode(); @Override boolean equals(Object other); }### Answer:
@Test public void testHashCode() { assertEquals(guangdong.hashCode(), new Company("Guangdong", 1).hashCode()); } |
### Question:
BaseEntity implements Entity { @Override public boolean equals(Object other) { return EntityEqualsBuilder.isEquals(this, other); } @Override boolean existed(); @Override boolean notExisted(); static void setRepository(EntityRepository repository); String[] businessKeys(); @Override int hashCode(); @Override boolean equals(Object other); }### Answer:
@Test public void testEquals() { assertTrue(guangdong.equals(guangdong)); assertFalse(guangdong.equals(guangzhou)); assertFalse(guangdong.equals(financial)); guangdong.disable(); assertTrue(guangdong.equals(new Company("Guangdong", 1))); assertTrue(new Company("Guangdong", 1).equals(guangdong)); } |
### Question:
AbstractEntity extends BaseEntity { public void save() { getRepository().save(this); } @Override Long getId(); void setId(Long id); int getVersion(); void setVersion(int version); void save(); void remove(); static T get(Class<T> clazz, Serializable id); static T getUnmodified(Class<T> clazz, T entity); static T load(Class<T> clazz, Serializable id); static List<T> findAll(Class<T> clazz); static List<T> findByProperty(Class<T> clazz, String propName, Object value); static List<T> findByProperties(Class<T> clazz, Map<String, Object> propValues); }### Answer:
@Test public void testSave() { instance.save(); verify(repository.save(instance)); } |
### Question:
AbstractEntity extends BaseEntity { public void remove() { getRepository().remove(this); } @Override Long getId(); void setId(Long id); int getVersion(); void setVersion(int version); void save(); void remove(); static T get(Class<T> clazz, Serializable id); static T getUnmodified(Class<T> clazz, T entity); static T load(Class<T> clazz, Serializable id); static List<T> findAll(Class<T> clazz); static List<T> findByProperty(Class<T> clazz, String propName, Object value); static List<T> findByProperties(Class<T> clazz, Map<String, Object> propValues); }### Answer:
@Test public void testRemove() { instance.remove(); verify(repository).remove(instance); } |
### Question:
AbstractEntity extends BaseEntity { public static <T extends Entity> T get(Class<T> clazz, Serializable id) { return getRepository().get(clazz, id); } @Override Long getId(); void setId(Long id); int getVersion(); void setVersion(int version); void save(); void remove(); static T get(Class<T> clazz, Serializable id); static T getUnmodified(Class<T> clazz, T entity); static T load(Class<T> clazz, Serializable id); static List<T> findAll(Class<T> clazz); static List<T> findByProperty(Class<T> clazz, String propName, Object value); static List<T> findByProperties(Class<T> clazz, Map<String, Object> propValues); }### Answer:
@Test public void testGet() { when(repository.get(MyEntity.class, 3L)).thenReturn(instance); assertEquals(instance, AbstractEntity.get(MyEntity.class, 3L)); } |
### Question:
AbstractEntity extends BaseEntity { public static <T extends Entity> T getUnmodified(Class<T> clazz, T entity) { return getRepository().getUnmodified(clazz, entity); } @Override Long getId(); void setId(Long id); int getVersion(); void setVersion(int version); void save(); void remove(); static T get(Class<T> clazz, Serializable id); static T getUnmodified(Class<T> clazz, T entity); static T load(Class<T> clazz, Serializable id); static List<T> findAll(Class<T> clazz); static List<T> findByProperty(Class<T> clazz, String propName, Object value); static List<T> findByProperties(Class<T> clazz, Map<String, Object> propValues); }### Answer:
@Test public void testGetUnmodified() { MyEntity entity2 = new MyEntity("nnn"); when(repository.getUnmodified(MyEntity.class, instance)).thenReturn(entity2); assertEquals(entity2, AbstractEntity.getUnmodified(MyEntity.class, instance)); } |
### Question:
AbstractEntity extends BaseEntity { public static <T extends Entity> T load(Class<T> clazz, Serializable id) { return getRepository().load(clazz, id); } @Override Long getId(); void setId(Long id); int getVersion(); void setVersion(int version); void save(); void remove(); static T get(Class<T> clazz, Serializable id); static T getUnmodified(Class<T> clazz, T entity); static T load(Class<T> clazz, Serializable id); static List<T> findAll(Class<T> clazz); static List<T> findByProperty(Class<T> clazz, String propName, Object value); static List<T> findByProperties(Class<T> clazz, Map<String, Object> propValues); }### Answer:
@Test public void testLoad() { when(repository.load(MyEntity.class, 3L)).thenReturn(instance); assertEquals(instance, AbstractEntity.load(MyEntity.class, 3L)); } |
### Question:
AbstractEntity extends BaseEntity { public static <T extends Entity> List<T> findAll(Class<T> clazz) { return getRepository().createCriteriaQuery(clazz).list(); } @Override Long getId(); void setId(Long id); int getVersion(); void setVersion(int version); void save(); void remove(); static T get(Class<T> clazz, Serializable id); static T getUnmodified(Class<T> clazz, T entity); static T load(Class<T> clazz, Serializable id); static List<T> findAll(Class<T> clazz); static List<T> findByProperty(Class<T> clazz, String propName, Object value); static List<T> findByProperties(Class<T> clazz, Map<String, Object> propValues); }### Answer:
@Test public void testFindAll() { List list = Arrays.asList("a", "b"); CriteriaQuery query = mock(CriteriaQuery.class); when(repository.createCriteriaQuery(MyEntity.class)).thenReturn(query); when(query.list()).thenReturn(list); assertEquals(list, AbstractEntity.findAll(MyEntity.class)); } |
### Question:
AbstractEntity extends BaseEntity { public static <T extends Entity> List<T> findByProperty(Class<T> clazz, String propName, Object value) { return getRepository().findByProperty(clazz, propName, value); } @Override Long getId(); void setId(Long id); int getVersion(); void setVersion(int version); void save(); void remove(); static T get(Class<T> clazz, Serializable id); static T getUnmodified(Class<T> clazz, T entity); static T load(Class<T> clazz, Serializable id); static List<T> findAll(Class<T> clazz); static List<T> findByProperty(Class<T> clazz, String propName, Object value); static List<T> findByProperties(Class<T> clazz, Map<String, Object> propValues); }### Answer:
@Test public void testFindByProperty() { List list = Collections.singletonList(instance); when(repository.findByProperty(MyEntity.class, "name", "abc")).thenReturn(list); assertEquals(list, AbstractEntity.findByProperty(MyEntity.class, "name", "abc")); } |
### Question:
AbstractEntity extends BaseEntity { public static <T extends Entity> List<T> findByProperties(Class<T> clazz, Map<String, Object> propValues) { return getRepository().findByProperties(clazz, NamedParameters.create(propValues)); } @Override Long getId(); void setId(Long id); int getVersion(); void setVersion(int version); void save(); void remove(); static T get(Class<T> clazz, Serializable id); static T getUnmodified(Class<T> clazz, T entity); static T load(Class<T> clazz, Serializable id); static List<T> findAll(Class<T> clazz); static List<T> findByProperty(Class<T> clazz, String propName, Object value); static List<T> findByProperties(Class<T> clazz, Map<String, Object> propValues); }### Answer:
@Test public void testFindByProperties() { List list = Collections.singletonList(instance); Map props = Collections.singletonMap("name", "abc"); when(repository.findByProperties(MyEntity.class, NamedParameters.create(props))).thenReturn(list); assertEquals(list, AbstractEntity.findByProperties(MyEntity.class, props)); } |
### Question:
Util { public static long ip2long( String ip ) { String[] p = ip.split("\\."); if ( p.length != 4 ) return 0; int p1 = ((Integer.valueOf(p[0]) << 24) & 0xFF000000); int p2 = ((Integer.valueOf(p[1]) << 16) & 0x00FF0000); int p3 = ((Integer.valueOf(p[2]) << 8) & 0x0000FF00); int p4 = ((Integer.valueOf(p[3]) << 0) & 0x000000FF); return ((p1 | p2 | p3 | p4) & 0xFFFFFFFFL); } static void write( byte[] b, int offset, long v, int bytes); static void writeIntLong( byte[] b, int offset, long v ); static long getIntLong( byte[] b, int offset ); static int getInt3( byte[] b, int offset ); static int getInt2( byte[] b, int offset ); static int getInt1( byte[] b, int offset ); static long ip2long( String ip ); static String long2ip( long ip ); static boolean isIpAddress( String ip ); }### Answer:
@Test public void testUtil() { System.out.println(Util.ip2long("255.255.255.0")); } |
### Question:
FavoritesConflictResolutionPresenter implements
FavoritesConflictResolutionContract.Presenter { @Override public void subscribe() { populate(); } @Inject FavoritesConflictResolutionPresenter(
Repository repository, Settings settings,
LocalFavorites<Favorite> localFavorites, CloudItem<Favorite> cloudFavorites,
FavoritesConflictResolutionContract.View view,
FavoritesConflictResolutionContract.ViewModel viewModel,
BaseSchedulerProvider schedulerProvider, @FavoriteId String favoriteId); @Override void subscribe(); @Override void unsubscribe(); @Override void onLocalDeleteClick(); @Override void onCloudDeleteClick(); @Override void onCloudRetryClick(); @Override void onLocalUploadClick(); @Override void onCloudDownloadClick(); }### Answer:
@Test public void notConflictedFavorite_finishesActivityWithSuccess() { SyncState state = new SyncState(SyncState.State.SYNCED); Favorite favorite = new Favorite(defaultFavorite, state); when(localFavorites.get(eq(favoriteId))) .thenReturn(Single.just(favorite)); presenter.subscribe(); verify(repository).refreshFavorites(); verify(view).finishActivity(); }
@Test public void wrongId_finishesActivityWithSuccess() { when(localFavorites.get(eq(favoriteId))) .thenReturn(Single.error(new NoSuchElementException())); presenter.subscribe(); verify(repository).refreshFavorites(); verify(view).finishActivity(); }
@Test public void databaseError_showsErrorThenTriesToLoadCloudFavorite() { when(localFavorites.get(eq(favoriteId))) .thenReturn(Single.error(new NullPointerException())); when(cloudFavorites.download(eq(favoriteId))) .thenReturn(Single.just(defaultFavorite)); presenter.subscribe(); verify(viewModel).showDatabaseError(); verify(viewModel).populateCloudFavorite(eq(defaultFavorite)); }
@Test public void duplicatedFavoriteWithNoMainRecord_resolvesConflictAutomatically() { SyncState state = new SyncState(E_TAGL, 1); Favorite favorite = new Favorite(defaultFavorite, state); String favoriteId = favorite.getId(); when(localFavorites.get(eq(favoriteId))).thenReturn(Single.just(favorite)); when(localFavorites.getMain(eq(favorite.getDuplicatedKey()))) .thenReturn(Single.error(new NoSuchElementException())); when(viewModel.isCloudPopulated()).thenReturn(true); when(localFavorites.update(eq(favoriteId), any(SyncState.class))) .thenReturn(Single.just(true)); presenter.subscribe(); verify(viewModel).populateCloudFavorite(eq(favorite)); verify(repository).refreshFavorite(eq(favoriteId)); verify(view).finishActivity(); } |
### Question:
AddEditFavoritePresenter implements
AddEditFavoriteContract.Presenter, TokenCompleteTextView.TokenListener<Tag> { @Override public void populateFavorite() { if (favoriteId == null) { throw new RuntimeException("populateFavorite() was called but favoriteId is null"); } favoriteDisposable.clear(); Disposable disposable = repository.getFavorite(favoriteId) .subscribeOn(schedulerProvider.computation()) .observeOn(schedulerProvider.ui()) .subscribe(viewModel::populateFavorite, throwable -> { favoriteId = null; viewModel.showFavoriteNotFoundSnackbar(); }); favoriteDisposable.add(disposable); } @Inject AddEditFavoritePresenter(
Repository repository, AddEditFavoriteContract.View view,
AddEditFavoriteContract.ViewModel viewModel,
BaseSchedulerProvider schedulerProvider,
Settings settings, @Nullable @FavoriteId String favoriteId); @Override void subscribe(); @Override void unsubscribe(); @Override void loadTags(); @Override boolean isNewFavorite(); @Override void populateFavorite(); @Override void saveFavorite(String name, boolean andGate, List<Tag> tags); @Override void onClipboardChanged(int clipboardType, boolean force); @Override void onClipboardLinkExtraReady(boolean force); @Override void setShowFillInFormInfo(boolean show); @Override boolean isShowFillInFormInfo(); @Override void onTokenAdded(Tag tag); @Override void onTokenRemoved(Tag tag); @Override void onDuplicateRemoved(Tag tag); }### Answer:
@Test public void populateFavorite_callsRepositoryAndUpdateViewOnSuccess() { final String favoriteId = defaultFavorite.getId(); when(repository.getFavorite(favoriteId)).thenReturn(Single.just(defaultFavorite)); AddEditFavoritePresenter presenter = new AddEditFavoritePresenter( repository, view, viewModel, schedulerProvider, settings, favoriteId); presenter.populateFavorite(); verify(repository).getFavorite(favoriteId); verify(viewModel).populateFavorite(any(Favorite.class)); }
@Test public void populateFavorite_callsRepositoryAndShowsWarningOnError() { final String favoriteId = defaultFavorite.getId(); when(repository.getFavorite(favoriteId)).thenReturn(Single.error(new NoSuchElementException())); AddEditFavoritePresenter presenter = new AddEditFavoritePresenter( repository, view, viewModel, schedulerProvider, settings, favoriteId); presenter.populateFavorite(); verify(repository).getFavorite(favoriteId); verify(viewModel, never()).populateFavorite(any(Favorite.class)); verify(viewModel).showFavoriteNotFoundSnackbar(); } |
### Question:
FavoritesPresenter extends BaseItemPresenter implements
FavoritesContract.Presenter, DataSource.Callback { @Override public void loadFavorites(final boolean forceUpdate) { loadFavorites(forceUpdate, false); } @Inject FavoritesPresenter(
Repository repository, FavoritesContract.View view,
FavoritesContract.ViewModel viewModel, BaseSchedulerProvider schedulerProvider,
LaanoUiManager laanoUiManager, Settings settings); @Override void subscribe(); @Override void unsubscribe(); @Override void onTabSelected(); @Override void onTabDeselected(); @Override void showAddFavorite(); @Override void loadFavorites(final boolean forceUpdate); @Override void onFavoriteClick(String favoriteId, boolean isConflicted); @Override boolean onFavoriteLongClick(String favoriteId); @Override void onCheckboxClick(String favoriteId); @Override void selectFavoriteFilter(); @Override void onEditClick(@NonNull String favoriteId); @Override void onToLinksClick(@NonNull Favorite favoriteFilter); @Override void onToNotesClick(@NonNull Favorite favoriteFilter); @Override void onDeleteClick(); @Override void onSelectAllClick(); @Override void syncSavedFavorite(@NonNull final String favoriteId); @Override void deleteFavorites(@NonNull ArrayList<String> selectedIds); @Override void updateSyncStatus(); @Override int getPosition(String favoriteId); @Override void setFilterType(@NonNull FilterType filterType); @Override @NonNull FilterType getFilterType(); @Override void updateTabNormalState(); @Override void onRepositoryDelete(@NonNull String id, @NonNull DataSource.ItemState itemState); @Override void onRepositorySave(@NonNull String id, @NonNull DataSource.ItemState itemState); @Override void setFilterIsChanged(boolean filterIsChanged); static final String SETTING_FAVORITES_FILTER_TYPE; }### Answer:
@Test public void loadEmptyListOfFavorites_showsEmptyList() { when(repository.getFavorites()).thenReturn(Observable.fromIterable(Collections.emptyList())); presenter.loadFavorites(true); verify(view).showFavorites(favoriteListCaptor.capture()); assertEquals(favoriteListCaptor.getValue().size(), 0); } |
### Question:
FavoritesPresenter extends BaseItemPresenter implements
FavoritesContract.Presenter, DataSource.Callback { @Override public void showAddFavorite() { view.startAddFavoriteActivity(); } @Inject FavoritesPresenter(
Repository repository, FavoritesContract.View view,
FavoritesContract.ViewModel viewModel, BaseSchedulerProvider schedulerProvider,
LaanoUiManager laanoUiManager, Settings settings); @Override void subscribe(); @Override void unsubscribe(); @Override void onTabSelected(); @Override void onTabDeselected(); @Override void showAddFavorite(); @Override void loadFavorites(final boolean forceUpdate); @Override void onFavoriteClick(String favoriteId, boolean isConflicted); @Override boolean onFavoriteLongClick(String favoriteId); @Override void onCheckboxClick(String favoriteId); @Override void selectFavoriteFilter(); @Override void onEditClick(@NonNull String favoriteId); @Override void onToLinksClick(@NonNull Favorite favoriteFilter); @Override void onToNotesClick(@NonNull Favorite favoriteFilter); @Override void onDeleteClick(); @Override void onSelectAllClick(); @Override void syncSavedFavorite(@NonNull final String favoriteId); @Override void deleteFavorites(@NonNull ArrayList<String> selectedIds); @Override void updateSyncStatus(); @Override int getPosition(String favoriteId); @Override void setFilterType(@NonNull FilterType filterType); @Override @NonNull FilterType getFilterType(); @Override void updateTabNormalState(); @Override void onRepositoryDelete(@NonNull String id, @NonNull DataSource.ItemState itemState); @Override void onRepositorySave(@NonNull String id, @NonNull DataSource.ItemState itemState); @Override void setFilterIsChanged(boolean filterIsChanged); static final String SETTING_FAVORITES_FILTER_TYPE; }### Answer:
@Test public void clickOnAddFavorite_showAddFavoriteUi() { presenter.showAddFavorite(); verify(view).startAddFavoriteActivity(); } |
### Question:
FavoritesPresenter extends BaseItemPresenter implements
FavoritesContract.Presenter, DataSource.Callback { @Override public void onEditClick(@NonNull String favoriteId) { checkNotNull(favoriteId); view.showEditFavorite(favoriteId); } @Inject FavoritesPresenter(
Repository repository, FavoritesContract.View view,
FavoritesContract.ViewModel viewModel, BaseSchedulerProvider schedulerProvider,
LaanoUiManager laanoUiManager, Settings settings); @Override void subscribe(); @Override void unsubscribe(); @Override void onTabSelected(); @Override void onTabDeselected(); @Override void showAddFavorite(); @Override void loadFavorites(final boolean forceUpdate); @Override void onFavoriteClick(String favoriteId, boolean isConflicted); @Override boolean onFavoriteLongClick(String favoriteId); @Override void onCheckboxClick(String favoriteId); @Override void selectFavoriteFilter(); @Override void onEditClick(@NonNull String favoriteId); @Override void onToLinksClick(@NonNull Favorite favoriteFilter); @Override void onToNotesClick(@NonNull Favorite favoriteFilter); @Override void onDeleteClick(); @Override void onSelectAllClick(); @Override void syncSavedFavorite(@NonNull final String favoriteId); @Override void deleteFavorites(@NonNull ArrayList<String> selectedIds); @Override void updateSyncStatus(); @Override int getPosition(String favoriteId); @Override void setFilterType(@NonNull FilterType filterType); @Override @NonNull FilterType getFilterType(); @Override void updateTabNormalState(); @Override void onRepositoryDelete(@NonNull String id, @NonNull DataSource.ItemState itemState); @Override void onRepositorySave(@NonNull String id, @NonNull DataSource.ItemState itemState); @Override void setFilterIsChanged(boolean filterIsChanged); static final String SETTING_FAVORITES_FILTER_TYPE; }### Answer:
@Test public void clickOnEditFavorite_showEditFavoriteUi() { final String favoriteId = FAVORITES.get(0).getId(); presenter.onEditClick(favoriteId); verify(view).showEditFavorite(eq(favoriteId)); } |
### Question:
FavoritesPresenter extends BaseItemPresenter implements
FavoritesContract.Presenter, DataSource.Callback { @Override public void onDeleteClick() { ArrayList<String> selectedIds = viewModel.getSelectedIds(); view.confirmFavoritesRemoval(selectedIds); } @Inject FavoritesPresenter(
Repository repository, FavoritesContract.View view,
FavoritesContract.ViewModel viewModel, BaseSchedulerProvider schedulerProvider,
LaanoUiManager laanoUiManager, Settings settings); @Override void subscribe(); @Override void unsubscribe(); @Override void onTabSelected(); @Override void onTabDeselected(); @Override void showAddFavorite(); @Override void loadFavorites(final boolean forceUpdate); @Override void onFavoriteClick(String favoriteId, boolean isConflicted); @Override boolean onFavoriteLongClick(String favoriteId); @Override void onCheckboxClick(String favoriteId); @Override void selectFavoriteFilter(); @Override void onEditClick(@NonNull String favoriteId); @Override void onToLinksClick(@NonNull Favorite favoriteFilter); @Override void onToNotesClick(@NonNull Favorite favoriteFilter); @Override void onDeleteClick(); @Override void onSelectAllClick(); @Override void syncSavedFavorite(@NonNull final String favoriteId); @Override void deleteFavorites(@NonNull ArrayList<String> selectedIds); @Override void updateSyncStatus(); @Override int getPosition(String favoriteId); @Override void setFilterType(@NonNull FilterType filterType); @Override @NonNull FilterType getFilterType(); @Override void updateTabNormalState(); @Override void onRepositoryDelete(@NonNull String id, @NonNull DataSource.ItemState itemState); @Override void onRepositorySave(@NonNull String id, @NonNull DataSource.ItemState itemState); @Override void setFilterIsChanged(boolean filterIsChanged); static final String SETTING_FAVORITES_FILTER_TYPE; }### Answer:
@Test public void clickOnDeleteFavorite_showsConfirmFavoritesRemoval() { ArrayList<String> selectedIds = new ArrayList<String>() {{ add(FAVORITES.get(0).getId()); add(FAVORITES.get(2).getId()); }}; when(viewModel.getSelectedIds()).thenReturn(selectedIds); presenter.onDeleteClick(); verify(view).confirmFavoritesRemoval(eq(selectedIds)); } |
### Question:
NotesConflictResolutionPresenter implements
NotesConflictResolutionContract.Presenter { @Override public void subscribe() { populate(); } @Inject NotesConflictResolutionPresenter(
Repository repository, Settings settings,
LocalNotes<Note> localNotes, CloudItem<Note> cloudNotes,
LocalLinks<Link> localLinks, NotesConflictResolutionContract.View view,
NotesConflictResolutionContract.ViewModel viewModel,
BaseSchedulerProvider schedulerProvider, @NoteId String noteId); @Override void subscribe(); @Override void unsubscribe(); @Override void onLocalDeleteClick(); @Override void onCloudDeleteClick(); @Override void onCloudRetryClick(); @Override void onLocalUploadClick(); @Override void onCloudDownloadClick(); }### Answer:
@Test public void notConflictedNote_finishesActivityWithSuccess() { SyncState state = new SyncState(SyncState.State.SYNCED); Note note = new Note(defaultNote, state); when(localNotes.get(eq(noteId))).thenReturn(Single.just(note)); presenter.subscribe(); verify(repository).refreshNotes(); verify(view).finishActivity(); }
@Test public void wrongId_finishesActivityWithSuccess() { when(localNotes.get(eq(noteId))).thenReturn(Single.error(new NoSuchElementException())); presenter.subscribe(); verify(repository).refreshNotes(); verify(view).finishActivity(); }
@Test public void databaseError_showsErrorThenTriesToLoadCloudNote() { when(localNotes.get(eq(noteId))).thenReturn(Single.error(new NullPointerException())); when(cloudNotes.download(eq(noteId))).thenReturn(Single.just(defaultNote)); presenter.subscribe(); verify(viewModel).showDatabaseError(); verify(viewModel).populateCloudNote(eq(defaultNote), eq(false)); } |
### Question:
AddEditNotePresenter implements
AddEditNoteContract.Presenter, TokenCompleteTextView.TokenListener<Tag> { @Override public void loadTags() { tagsDisposable.clear(); Disposable disposable = repository.getTags() .subscribeOn(schedulerProvider.computation()) .toList() .observeOn(schedulerProvider.ui()) .subscribe(view::swapTagsCompletionViewItems, throwable -> { CommonUtils.logStackTrace(TAG_E, throwable); view.swapTagsCompletionViewItems(new ArrayList<>()); }); tagsDisposable.add(disposable); } @Inject AddEditNotePresenter(
Repository repository, AddEditNoteContract.View view,
AddEditNoteContract.ViewModel viewModel, BaseSchedulerProvider schedulerProvider,
Settings settings,
@Nullable @NoteId String noteId, @Nullable @LinkId String linkId); @Override void subscribe(); @Override void unsubscribe(); @Override void loadTags(); @Override boolean isNewNote(); @Override void populateNote(); @Override void saveNote(String noteNote, List<Tag> noteTags); @Override void onClipboardChanged(int clipboardType, boolean force); @Override void onClipboardLinkExtraReady(boolean force); @Override void setShowFillInFormInfo(boolean show); @Override boolean isShowFillInFormInfo(); @Override void onTokenAdded(Tag token); @Override void onTokenRemoved(Tag token); @Override void onDuplicateRemoved(Tag token); }### Answer:
@Test public void loadAllTagsFromRepository_loadsItIntoView() { List<Tag> tags = defaultNote.getTags(); assertNotNull(tags); when(repository.getTags()).thenReturn(Observable.fromIterable(tags)); presenter.loadTags(); verify(view).swapTagsCompletionViewItems(eq(tags)); }
@Test public void loadEmptyListOfTags_loadsEmptyListIntoView() { when(repository.getTags()).thenReturn(Observable.fromIterable(Collections.emptyList())); presenter.loadTags(); verify(view).swapTagsCompletionViewItems(tagListCaptor.capture()); assertEquals(tagListCaptor.getValue().size(), 0); } |
### Question:
AddEditNotePresenter implements
AddEditNoteContract.Presenter, TokenCompleteTextView.TokenListener<Tag> { @Override public void saveNote(String noteNote, List<Tag> noteTags) { if (isNewNote()) { createNote(noteNote, noteTags); } else { updateNote(noteNote, noteTags); } } @Inject AddEditNotePresenter(
Repository repository, AddEditNoteContract.View view,
AddEditNoteContract.ViewModel viewModel, BaseSchedulerProvider schedulerProvider,
Settings settings,
@Nullable @NoteId String noteId, @Nullable @LinkId String linkId); @Override void subscribe(); @Override void unsubscribe(); @Override void loadTags(); @Override boolean isNewNote(); @Override void populateNote(); @Override void saveNote(String noteNote, List<Tag> noteTags); @Override void onClipboardChanged(int clipboardType, boolean force); @Override void onClipboardLinkExtraReady(boolean force); @Override void setShowFillInFormInfo(boolean show); @Override boolean isShowFillInFormInfo(); @Override void onTokenAdded(Tag token); @Override void onTokenRemoved(Tag token); @Override void onDuplicateRemoved(Tag token); }### Answer:
@Test public void saveNewNoteToRepository_finishesActivity() { String noteNote = defaultNote.getNote(); String linkId = defaultNote.getLinkId(); List<Tag> noteTags = defaultNote.getTags(); when(repository.saveNote(any(Note.class), eq(false))) .thenReturn(Observable.just(DataSource.ItemState.DEFERRED)); presenter.saveNote(noteNote, noteTags); verify(repository, never()).refreshNotes(); verify(view).finishActivity(any(String.class), eq(linkId)); }
@Test public void saveEmptyNote_showsEmptyError() { presenter.saveNote("", new ArrayList<>()); presenter.saveNote("", defaultNote.getTags()); verify(viewModel, times(2)).showEmptyNoteSnackbar(); }
@Test public void saveExistingNote_finishesActivity() { String noteId = defaultNote.getId(); String linkId = defaultNote.getLinkId(); String noteNote = defaultNote.getNote(); List<Tag> noteTags = defaultNote.getTags(); when(repository.saveNote(any(Note.class), eq(false))) .thenReturn(Observable.just(DataSource.ItemState.DEFERRED)); AddEditNotePresenter presenter = new AddEditNotePresenter( repository, view, viewModel, schedulerProvider, settings, noteId, linkId); presenter.saveNote(noteNote, noteTags); verify(repository, never()).refreshNotes(); verify(view).finishActivity(eq(noteId), eq(linkId)); } |
### Question:
AddEditNotePresenter implements
AddEditNoteContract.Presenter, TokenCompleteTextView.TokenListener<Tag> { @Override public void populateNote() { if (noteId == null) { throw new RuntimeException("populateNote() was called but noteId is null"); } noteDisposable.clear(); Disposable disposable = repository.getNote(noteId) .subscribeOn(schedulerProvider.computation()) .observeOn(schedulerProvider.ui()) .subscribe(note -> { viewModel.populateNote(note); linkId = note.getLinkId(); populateLink(); }, throwable -> { noteId = null; viewModel.showNoteNotFoundSnackbar(); }); noteDisposable.add(disposable); } @Inject AddEditNotePresenter(
Repository repository, AddEditNoteContract.View view,
AddEditNoteContract.ViewModel viewModel, BaseSchedulerProvider schedulerProvider,
Settings settings,
@Nullable @NoteId String noteId, @Nullable @LinkId String linkId); @Override void subscribe(); @Override void unsubscribe(); @Override void loadTags(); @Override boolean isNewNote(); @Override void populateNote(); @Override void saveNote(String noteNote, List<Tag> noteTags); @Override void onClipboardChanged(int clipboardType, boolean force); @Override void onClipboardLinkExtraReady(boolean force); @Override void setShowFillInFormInfo(boolean show); @Override boolean isShowFillInFormInfo(); @Override void onTokenAdded(Tag token); @Override void onTokenRemoved(Tag token); @Override void onDuplicateRemoved(Tag token); }### Answer:
@Test public void populateNote_callsRepositoryAndUpdateViewOnSuccess() { final String noteId = defaultNote.getId(); when(repository.getNote(noteId)).thenReturn(Single.just(defaultNote)); AddEditNotePresenter presenter = new AddEditNotePresenter( repository, view, viewModel, schedulerProvider, settings, noteId, defaultNote.getLinkId()); presenter.populateNote(); verify(repository).getNote(noteId); verify(viewModel).populateNote(any(Note.class)); }
@Test public void populateNote_callsRepositoryAndShowsWarningOnError() { final String noteId = defaultNote.getId(); when(repository.getNote(noteId)).thenReturn(Single.error(new NoSuchElementException())); AddEditNotePresenter presenter = new AddEditNotePresenter( repository, view, viewModel, schedulerProvider, settings, noteId, defaultNote.getLinkId()); presenter.populateNote(); verify(repository).getNote(noteId); verify(viewModel, never()).populateNote(any(Note.class)); verify(viewModel).showNoteNotFoundSnackbar(); } |
### Question:
NotesPresenter extends BaseItemPresenter implements
NotesContract.Presenter, DataSource.Callback { @Override public void loadNotes(final boolean forceUpdate) { loadNotes(forceUpdate, false); } @Inject NotesPresenter(
Repository repository, NotesContract.View view,
NotesContract.ViewModel viewModel, BaseSchedulerProvider schedulerProvider,
LaanoUiManager laanoUiManager, Settings settings); @Override void subscribe(); @Override void unsubscribe(); @Override void onTabSelected(); @Override void onTabDeselected(); @Override void showAddNote(); @Override void loadNotes(final boolean forceUpdate); @Override void onNoteClick(String noteId, boolean isConflicted); @Override boolean onNoteLongClick(String noteId); @Override void onCheckboxClick(String noteId); @Override void selectNoteFilter(); @Override void onEditClick(@NonNull String noteId); @Override void onToLinksClick(@NonNull String noteId); @Override void onToggleClick(@NonNull String noteId); @Override void onDeleteClick(); @Override void onSelectAllClick(); @Override void syncSavedNote(final String linkId, @NonNull final String noteId); @Override void deleteNotes(ArrayList<String> selectedIds); @Override void updateSyncStatus(); @Override int getPosition(String noteId); @Override void setFilterType(@NonNull FilterType filterType); @Override @NonNull FilterType getFilterType(); @Override @Nullable Boolean isFavoriteAndGate(); @Override boolean isFavoriteFilter(); @Override boolean isLinkFilter(); @Override boolean isExpandNotes(); @Override void updateTabNormalState(); @Override boolean isNotesLayoutModeReading(); @Override boolean toggleNotesLayoutMode(); @Override void onRepositoryDelete(@NonNull String id, @NonNull DataSource.ItemState itemState); @Override void onRepositorySave(@NonNull String id, @NonNull DataSource.ItemState itemState); @Override void setFilterIsChanged(boolean filterIsChanged); static final String SETTING_NOTES_FILTER_TYPE; }### Answer:
@Test public void loadAllNotesFromRepository_loadsItIntoView() { when(repository.getNotes()).thenReturn(Observable.fromIterable(NOTES)); presenter.loadNotes(true); verify(view).showNotes(NOTES); }
@Test public void loadEmptyListOfNotes_showsEmptyList() { when(repository.getNotes()).thenReturn(Observable.fromIterable(Collections.emptyList())); presenter.loadNotes(true); verify(view).showNotes(noteListCaptor.capture()); assertEquals(noteListCaptor.getValue().size(), 0); } |
### Question:
NotesPresenter extends BaseItemPresenter implements
NotesContract.Presenter, DataSource.Callback { @Override public void showAddNote() { view.startAddNoteActivity(filterType == FilterType.LINK ? linkFilterId : null); } @Inject NotesPresenter(
Repository repository, NotesContract.View view,
NotesContract.ViewModel viewModel, BaseSchedulerProvider schedulerProvider,
LaanoUiManager laanoUiManager, Settings settings); @Override void subscribe(); @Override void unsubscribe(); @Override void onTabSelected(); @Override void onTabDeselected(); @Override void showAddNote(); @Override void loadNotes(final boolean forceUpdate); @Override void onNoteClick(String noteId, boolean isConflicted); @Override boolean onNoteLongClick(String noteId); @Override void onCheckboxClick(String noteId); @Override void selectNoteFilter(); @Override void onEditClick(@NonNull String noteId); @Override void onToLinksClick(@NonNull String noteId); @Override void onToggleClick(@NonNull String noteId); @Override void onDeleteClick(); @Override void onSelectAllClick(); @Override void syncSavedNote(final String linkId, @NonNull final String noteId); @Override void deleteNotes(ArrayList<String> selectedIds); @Override void updateSyncStatus(); @Override int getPosition(String noteId); @Override void setFilterType(@NonNull FilterType filterType); @Override @NonNull FilterType getFilterType(); @Override @Nullable Boolean isFavoriteAndGate(); @Override boolean isFavoriteFilter(); @Override boolean isLinkFilter(); @Override boolean isExpandNotes(); @Override void updateTabNormalState(); @Override boolean isNotesLayoutModeReading(); @Override boolean toggleNotesLayoutMode(); @Override void onRepositoryDelete(@NonNull String id, @NonNull DataSource.ItemState itemState); @Override void onRepositorySave(@NonNull String id, @NonNull DataSource.ItemState itemState); @Override void setFilterIsChanged(boolean filterIsChanged); static final String SETTING_NOTES_FILTER_TYPE; }### Answer:
@Test public void clickOnAddNote_showAddNoteUiForUnboundNote() { presenter.showAddNote(); verify(view).startAddNoteActivity(eq(null)); } |
### Question:
NotesPresenter extends BaseItemPresenter implements
NotesContract.Presenter, DataSource.Callback { @Override public void onEditClick(@NonNull String noteId) { checkNotNull(noteId); view.showEditNote(noteId); } @Inject NotesPresenter(
Repository repository, NotesContract.View view,
NotesContract.ViewModel viewModel, BaseSchedulerProvider schedulerProvider,
LaanoUiManager laanoUiManager, Settings settings); @Override void subscribe(); @Override void unsubscribe(); @Override void onTabSelected(); @Override void onTabDeselected(); @Override void showAddNote(); @Override void loadNotes(final boolean forceUpdate); @Override void onNoteClick(String noteId, boolean isConflicted); @Override boolean onNoteLongClick(String noteId); @Override void onCheckboxClick(String noteId); @Override void selectNoteFilter(); @Override void onEditClick(@NonNull String noteId); @Override void onToLinksClick(@NonNull String noteId); @Override void onToggleClick(@NonNull String noteId); @Override void onDeleteClick(); @Override void onSelectAllClick(); @Override void syncSavedNote(final String linkId, @NonNull final String noteId); @Override void deleteNotes(ArrayList<String> selectedIds); @Override void updateSyncStatus(); @Override int getPosition(String noteId); @Override void setFilterType(@NonNull FilterType filterType); @Override @NonNull FilterType getFilterType(); @Override @Nullable Boolean isFavoriteAndGate(); @Override boolean isFavoriteFilter(); @Override boolean isLinkFilter(); @Override boolean isExpandNotes(); @Override void updateTabNormalState(); @Override boolean isNotesLayoutModeReading(); @Override boolean toggleNotesLayoutMode(); @Override void onRepositoryDelete(@NonNull String id, @NonNull DataSource.ItemState itemState); @Override void onRepositorySave(@NonNull String id, @NonNull DataSource.ItemState itemState); @Override void setFilterIsChanged(boolean filterIsChanged); static final String SETTING_NOTES_FILTER_TYPE; }### Answer:
@Test public void clickOnEditNote_showEditNoteUi() { final String noteId = NOTES.get(0).getId(); presenter.onEditClick(noteId); verify(view).showEditNote(eq(noteId)); } |
### Question:
NotesPresenter extends BaseItemPresenter implements
NotesContract.Presenter, DataSource.Callback { @Override public void onDeleteClick() { ArrayList<String> selectedIds = viewModel.getSelectedIds(); view.confirmNotesRemoval(selectedIds); } @Inject NotesPresenter(
Repository repository, NotesContract.View view,
NotesContract.ViewModel viewModel, BaseSchedulerProvider schedulerProvider,
LaanoUiManager laanoUiManager, Settings settings); @Override void subscribe(); @Override void unsubscribe(); @Override void onTabSelected(); @Override void onTabDeselected(); @Override void showAddNote(); @Override void loadNotes(final boolean forceUpdate); @Override void onNoteClick(String noteId, boolean isConflicted); @Override boolean onNoteLongClick(String noteId); @Override void onCheckboxClick(String noteId); @Override void selectNoteFilter(); @Override void onEditClick(@NonNull String noteId); @Override void onToLinksClick(@NonNull String noteId); @Override void onToggleClick(@NonNull String noteId); @Override void onDeleteClick(); @Override void onSelectAllClick(); @Override void syncSavedNote(final String linkId, @NonNull final String noteId); @Override void deleteNotes(ArrayList<String> selectedIds); @Override void updateSyncStatus(); @Override int getPosition(String noteId); @Override void setFilterType(@NonNull FilterType filterType); @Override @NonNull FilterType getFilterType(); @Override @Nullable Boolean isFavoriteAndGate(); @Override boolean isFavoriteFilter(); @Override boolean isLinkFilter(); @Override boolean isExpandNotes(); @Override void updateTabNormalState(); @Override boolean isNotesLayoutModeReading(); @Override boolean toggleNotesLayoutMode(); @Override void onRepositoryDelete(@NonNull String id, @NonNull DataSource.ItemState itemState); @Override void onRepositorySave(@NonNull String id, @NonNull DataSource.ItemState itemState); @Override void setFilterIsChanged(boolean filterIsChanged); static final String SETTING_NOTES_FILTER_TYPE; }### Answer:
@Test public void clickOnDeleteNote_showsConfirmNotesRemoval() { ArrayList<String> selectedIds = new ArrayList<String>() {{ add(NOTES.get(0).getId()); add(NOTES.get(2).getId()); }}; when(viewModel.getSelectedIds()).thenReturn(selectedIds); presenter.onDeleteClick(); verify(view).confirmNotesRemoval(eq(selectedIds)); } |
### Question:
LinksConflictResolutionPresenter implements
LinksConflictResolutionContract.Presenter { @Override public void subscribe() { populate(); } @Inject LinksConflictResolutionPresenter(
Repository repository, Settings settings,
LocalLinks<Link> localLinks, CloudItem<Link> cloudLinks,
LocalNotes<Note> localNotes, CloudItem<Note> cloudNotes,
LinksConflictResolutionContract.View view,
LinksConflictResolutionContract.ViewModel viewModel,
BaseSchedulerProvider schedulerProvider, @LinkId String linkId); @Override void subscribe(); @Override void unsubscribe(); @Override void onLocalDeleteClick(); @Override void onCloudDeleteClick(); @Override void onCloudRetryClick(); @Override void onLocalUploadClick(); @Override void onCloudDownloadClick(); }### Answer:
@Test public void notConflictedLink_finishesActivityWithSuccess() { SyncState state = new SyncState(SyncState.State.SYNCED); Link link = new Link(defaultLink, state); when(localLinks.get(eq(linkId))).thenReturn(Single.just(link)); presenter.subscribe(); verify(repository).refreshLinks(); verify(view).finishActivity(); }
@Test public void wrongId_finishesActivityWithSuccess() { when(localLinks.get(eq(linkId))).thenReturn(Single.error(new NoSuchElementException())); presenter.subscribe(); verify(repository).refreshLinks(); verify(view).finishActivity(); }
@Test public void databaseError_showsErrorThenTriesToLoadCloudLink() { when(localLinks.get(eq(linkId))).thenReturn(Single.error(new NullPointerException())); when(cloudLinks.download(eq(linkId))).thenReturn(Single.just(defaultLink)); presenter.subscribe(); verify(viewModel).showDatabaseError(); verify(viewModel).populateCloudLink(eq(defaultLink)); }
@Test public void duplicatedLinkWithNoMainRecord_resolvesConflictAutomatically() { SyncState state = new SyncState(E_TAGL, 1); Link link = new Link(defaultLink, state); String linkId = link.getId(); when(localLinks.get(eq(linkId))).thenReturn(Single.just(link)); when(localLinks.getMain(eq(link.getDuplicatedKey()))) .thenReturn(Single.error(new NoSuchElementException())); when(viewModel.isCloudPopulated()).thenReturn(true); when(localLinks.update(eq(linkId), any(SyncState.class))).thenReturn(Single.just(true)); presenter.subscribe(); verify(viewModel).populateCloudLink(eq(link)); verify(repository).refreshLink(eq(linkId)); verify(view).finishActivity(); } |
### Question:
LinksPresenter extends BaseItemPresenter implements
LinksContract.Presenter, DataSource.Callback { @Override public void loadLinks(final boolean forceUpdate) { loadLinks(forceUpdate, false); } @Inject LinksPresenter(
Repository repository, LinksContract.View view,
LinksContract.ViewModel viewModel, BaseSchedulerProvider schedulerProvider,
LaanoUiManager laanoUiManager, Settings settings); @Override void subscribe(); @Override void unsubscribe(); @Override void onTabSelected(); @Override void onTabDeselected(); @Override void showAddLink(); @Override void loadLinks(final boolean forceUpdate); @Override void onLinkClick(String linkId, boolean isConflicted, int numNotes); @Override boolean onLinkLongClick(String linkId); @Override void onCheckboxClick(String linkId); @Override void selectLinkFilter(); @Override void onEditClick(@NonNull String linkId); @Override void onLinkOpenClick(@NonNull String linkId); @Override void onToNotesClick(@NonNull String linkId); @Override void onAddNoteClick(@NonNull String linkId); @Override void onToggleClick(@NonNull String linkId); @Override void onDeleteClick(); @Override void onSelectAllClick(); @Override void syncSavedLink(@NonNull final String linkId); @Override void syncSavedNote(@NonNull final String linkId, @NonNull final String noteId); @Override void deleteLinks(
@NonNull final ArrayList<String> selectedIds, final boolean deleteNotes); @Override void updateSyncStatus(); @Override int getPosition(String linkId); @Override void setFilterType(@NonNull FilterType filterType); @Override @NonNull FilterType getFilterType(); @Override @Nullable Boolean isFavoriteAndGate(); @Override boolean isFavoriteFilter(); @Override boolean isNoteFilter(); @Override boolean isExpandLinks(); @Override void updateTabNormalState(); @Override void setShowConflictResolutionWarning(boolean show); @Override void onRepositoryDelete(@NonNull String id, @NonNull DataSource.ItemState itemState); @Override void onRepositorySave(@NonNull String id, @NonNull DataSource.ItemState itemState); @Override void setFilterIsChanged(boolean filterIsChanged); static final String SETTING_LINKS_FILTER_TYPE; }### Answer:
@Test public void loadAllLinksFromRepository_loadsItIntoView() { when(repository.getLinks()).thenReturn(Observable.fromIterable(LINKS)); presenter.loadLinks(true); verify(view).showLinks(LINKS); }
@Test public void loadEmptyListOfLinks_showsEmptyList() { when(repository.getLinks()).thenReturn(Observable.fromIterable(Collections.emptyList())); presenter.loadLinks(true); verify(view).showLinks(linkListCaptor.capture()); assertEquals(linkListCaptor.getValue().size(), 0); } |
### Question:
LinksPresenter extends BaseItemPresenter implements
LinksContract.Presenter, DataSource.Callback { @Override public void showAddLink() { view.startAddLinkActivity(); } @Inject LinksPresenter(
Repository repository, LinksContract.View view,
LinksContract.ViewModel viewModel, BaseSchedulerProvider schedulerProvider,
LaanoUiManager laanoUiManager, Settings settings); @Override void subscribe(); @Override void unsubscribe(); @Override void onTabSelected(); @Override void onTabDeselected(); @Override void showAddLink(); @Override void loadLinks(final boolean forceUpdate); @Override void onLinkClick(String linkId, boolean isConflicted, int numNotes); @Override boolean onLinkLongClick(String linkId); @Override void onCheckboxClick(String linkId); @Override void selectLinkFilter(); @Override void onEditClick(@NonNull String linkId); @Override void onLinkOpenClick(@NonNull String linkId); @Override void onToNotesClick(@NonNull String linkId); @Override void onAddNoteClick(@NonNull String linkId); @Override void onToggleClick(@NonNull String linkId); @Override void onDeleteClick(); @Override void onSelectAllClick(); @Override void syncSavedLink(@NonNull final String linkId); @Override void syncSavedNote(@NonNull final String linkId, @NonNull final String noteId); @Override void deleteLinks(
@NonNull final ArrayList<String> selectedIds, final boolean deleteNotes); @Override void updateSyncStatus(); @Override int getPosition(String linkId); @Override void setFilterType(@NonNull FilterType filterType); @Override @NonNull FilterType getFilterType(); @Override @Nullable Boolean isFavoriteAndGate(); @Override boolean isFavoriteFilter(); @Override boolean isNoteFilter(); @Override boolean isExpandLinks(); @Override void updateTabNormalState(); @Override void setShowConflictResolutionWarning(boolean show); @Override void onRepositoryDelete(@NonNull String id, @NonNull DataSource.ItemState itemState); @Override void onRepositorySave(@NonNull String id, @NonNull DataSource.ItemState itemState); @Override void setFilterIsChanged(boolean filterIsChanged); static final String SETTING_LINKS_FILTER_TYPE; }### Answer:
@Test public void clickOnAddLink_showAddLinkUi() { presenter.showAddLink(); verify(view).startAddLinkActivity(); } |
### Question:
LinksPresenter extends BaseItemPresenter implements
LinksContract.Presenter, DataSource.Callback { @Override public void onEditClick(@NonNull String linkId) { checkNotNull(linkId); view.showEditLink(linkId); } @Inject LinksPresenter(
Repository repository, LinksContract.View view,
LinksContract.ViewModel viewModel, BaseSchedulerProvider schedulerProvider,
LaanoUiManager laanoUiManager, Settings settings); @Override void subscribe(); @Override void unsubscribe(); @Override void onTabSelected(); @Override void onTabDeselected(); @Override void showAddLink(); @Override void loadLinks(final boolean forceUpdate); @Override void onLinkClick(String linkId, boolean isConflicted, int numNotes); @Override boolean onLinkLongClick(String linkId); @Override void onCheckboxClick(String linkId); @Override void selectLinkFilter(); @Override void onEditClick(@NonNull String linkId); @Override void onLinkOpenClick(@NonNull String linkId); @Override void onToNotesClick(@NonNull String linkId); @Override void onAddNoteClick(@NonNull String linkId); @Override void onToggleClick(@NonNull String linkId); @Override void onDeleteClick(); @Override void onSelectAllClick(); @Override void syncSavedLink(@NonNull final String linkId); @Override void syncSavedNote(@NonNull final String linkId, @NonNull final String noteId); @Override void deleteLinks(
@NonNull final ArrayList<String> selectedIds, final boolean deleteNotes); @Override void updateSyncStatus(); @Override int getPosition(String linkId); @Override void setFilterType(@NonNull FilterType filterType); @Override @NonNull FilterType getFilterType(); @Override @Nullable Boolean isFavoriteAndGate(); @Override boolean isFavoriteFilter(); @Override boolean isNoteFilter(); @Override boolean isExpandLinks(); @Override void updateTabNormalState(); @Override void setShowConflictResolutionWarning(boolean show); @Override void onRepositoryDelete(@NonNull String id, @NonNull DataSource.ItemState itemState); @Override void onRepositorySave(@NonNull String id, @NonNull DataSource.ItemState itemState); @Override void setFilterIsChanged(boolean filterIsChanged); static final String SETTING_LINKS_FILTER_TYPE; }### Answer:
@Test public void clickOnEditLink_showEditLinkUi() { final String linkId = LINKS.get(0).getId(); presenter.onEditClick(linkId); verify(view).showEditLink(eq(linkId)); } |
### Question:
LinksPresenter extends BaseItemPresenter implements
LinksContract.Presenter, DataSource.Callback { @Override public void onDeleteClick() { ArrayList<String> selectedIds = viewModel.getSelectedIds(); view.confirmLinksRemoval(selectedIds); } @Inject LinksPresenter(
Repository repository, LinksContract.View view,
LinksContract.ViewModel viewModel, BaseSchedulerProvider schedulerProvider,
LaanoUiManager laanoUiManager, Settings settings); @Override void subscribe(); @Override void unsubscribe(); @Override void onTabSelected(); @Override void onTabDeselected(); @Override void showAddLink(); @Override void loadLinks(final boolean forceUpdate); @Override void onLinkClick(String linkId, boolean isConflicted, int numNotes); @Override boolean onLinkLongClick(String linkId); @Override void onCheckboxClick(String linkId); @Override void selectLinkFilter(); @Override void onEditClick(@NonNull String linkId); @Override void onLinkOpenClick(@NonNull String linkId); @Override void onToNotesClick(@NonNull String linkId); @Override void onAddNoteClick(@NonNull String linkId); @Override void onToggleClick(@NonNull String linkId); @Override void onDeleteClick(); @Override void onSelectAllClick(); @Override void syncSavedLink(@NonNull final String linkId); @Override void syncSavedNote(@NonNull final String linkId, @NonNull final String noteId); @Override void deleteLinks(
@NonNull final ArrayList<String> selectedIds, final boolean deleteNotes); @Override void updateSyncStatus(); @Override int getPosition(String linkId); @Override void setFilterType(@NonNull FilterType filterType); @Override @NonNull FilterType getFilterType(); @Override @Nullable Boolean isFavoriteAndGate(); @Override boolean isFavoriteFilter(); @Override boolean isNoteFilter(); @Override boolean isExpandLinks(); @Override void updateTabNormalState(); @Override void setShowConflictResolutionWarning(boolean show); @Override void onRepositoryDelete(@NonNull String id, @NonNull DataSource.ItemState itemState); @Override void onRepositorySave(@NonNull String id, @NonNull DataSource.ItemState itemState); @Override void setFilterIsChanged(boolean filterIsChanged); static final String SETTING_LINKS_FILTER_TYPE; }### Answer:
@Test public void clickOnDeleteLink_showsConfirmLinksRemoval() { ArrayList<String> selectedIds = new ArrayList<String>() {{ add(LINKS.get(0).getId()); add(LINKS.get(2).getId()); }}; when(viewModel.getSelectedIds()).thenReturn(selectedIds); presenter.onDeleteClick(); verify(view).confirmLinksRemoval(eq(selectedIds)); } |
### Question:
AddEditLinkPresenter implements
AddEditLinkContract.Presenter, TokenCompleteTextView.TokenListener<Tag> { @Override public void loadTags() { tagsDisposable.clear(); Disposable disposable = repository.getTags() .subscribeOn(schedulerProvider.computation()) .toList() .observeOn(schedulerProvider.ui()) .subscribe(view::swapTagsCompletionViewItems, throwable -> { CommonUtils.logStackTrace(TAG_E, throwable); view.swapTagsCompletionViewItems(new ArrayList<>()); }); tagsDisposable.add(disposable); } @Inject AddEditLinkPresenter(
Repository repository, AddEditLinkContract.View view,
AddEditLinkContract.ViewModel viewModel, BaseSchedulerProvider schedulerProvider,
Settings settings, @Nullable @LinkId String linkId); @Override void subscribe(); @Override void unsubscribe(); @Override void loadTags(); @Override boolean isNewLink(); @Override void populateLink(); @Override void saveLink(
String linkLink, String linkName, boolean linkDisabled, List<Tag> linkTags); @Override void onClipboardChanged(int clipboardType, boolean force); @Override void onClipboardLinkExtraReady(boolean force); @Override void setShowFillInFormInfo(boolean show); @Override boolean isShowFillInFormInfo(); @Override void onTokenAdded(Tag token); @Override void onTokenRemoved(Tag token); @Override void onDuplicateRemoved(Tag token); }### Answer:
@Test public void loadAllTagsFromRepository_loadsItIntoView() { List<Tag> tags = defaultLink.getTags(); assertNotNull(tags); when(repository.getTags()).thenReturn(Observable.fromIterable(tags)); presenter.loadTags(); verify(view).swapTagsCompletionViewItems(eq(tags)); }
@Test public void loadEmptyListOfTags_loadsEmptyListIntoView() { when(repository.getTags()).thenReturn(Observable.fromIterable(Collections.emptyList())); presenter.loadTags(); verify(view).swapTagsCompletionViewItems(tagListCaptor.capture()); assertEquals(tagListCaptor.getValue().size(), 0); } |
### Question:
AddEditLinkPresenter implements
AddEditLinkContract.Presenter, TokenCompleteTextView.TokenListener<Tag> { @Override public void saveLink( String linkLink, String linkName, boolean linkDisabled, List<Tag> linkTags) { if (isNewLink()) { createLink(linkLink, linkName, linkDisabled, linkTags); } else { updateLink(linkLink, linkName, linkDisabled, linkTags); } } @Inject AddEditLinkPresenter(
Repository repository, AddEditLinkContract.View view,
AddEditLinkContract.ViewModel viewModel, BaseSchedulerProvider schedulerProvider,
Settings settings, @Nullable @LinkId String linkId); @Override void subscribe(); @Override void unsubscribe(); @Override void loadTags(); @Override boolean isNewLink(); @Override void populateLink(); @Override void saveLink(
String linkLink, String linkName, boolean linkDisabled, List<Tag> linkTags); @Override void onClipboardChanged(int clipboardType, boolean force); @Override void onClipboardLinkExtraReady(boolean force); @Override void setShowFillInFormInfo(boolean show); @Override boolean isShowFillInFormInfo(); @Override void onTokenAdded(Tag token); @Override void onTokenRemoved(Tag token); @Override void onDuplicateRemoved(Tag token); }### Answer:
@Test public void saveNewLinkToRepository_finishesActivity() { String linkLink = defaultLink.getLink(); String linkName = defaultLink.getName(); boolean linkDisabled = defaultLink.isDisabled(); List<Tag> linkTags = defaultLink.getTags(); when(repository.saveLink(any(Link.class), eq(false))) .thenReturn(Observable.just(DataSource.ItemState.DEFERRED)); presenter.saveLink(linkLink, linkName, linkDisabled, linkTags); verify(repository, never()).refreshLinks(); verify(view).finishActivity(any(String.class)); }
@Test public void saveEmptyLink_showsEmptyError() { presenter.saveLink(null, "", false, new ArrayList<>()); presenter.saveLink("", defaultLink.getName(), true, defaultLink.getTags()); verify(viewModel, times(2)).showEmptyLinkSnackbar(); }
@Test public void saveExistingLink_finishesActivity() { String linkId = defaultLink.getId(); String linkLink = defaultLink.getLink(); String linkName = defaultLink.getName(); boolean linkDisabled = defaultLink.isDisabled(); List<Tag> linkTags = defaultLink.getTags(); when(repository.saveLink(any(Link.class), eq(false))) .thenReturn(Observable.just(DataSource.ItemState.DEFERRED)); AddEditLinkPresenter presenter = new AddEditLinkPresenter( repository, view, viewModel, schedulerProvider, settings, linkId); presenter.saveLink(linkLink, linkName, linkDisabled, linkTags); verify(repository, never()).refreshLinks(); verify(view).finishActivity(eq(linkId)); }
@Test public void saveLinkWithExistedName_showsDuplicateError() { String linkId = defaultLink.getId(); String linkLink = defaultLink.getLink(); String linkName = defaultLink.getName(); boolean linkDisabled = defaultLink.isDisabled(); List<Tag> linkTags = defaultLink.getTags(); when(repository.saveLink(any(Link.class), eq(false))) .thenReturn(Observable.error(new SQLiteConstraintException())); presenter.saveLink(linkLink, linkName, linkDisabled, linkTags); verify(view, never()).finishActivity(eq(linkId)); verify(viewModel).showDuplicateKeyError(); } |
### Question:
AddEditLinkPresenter implements
AddEditLinkContract.Presenter, TokenCompleteTextView.TokenListener<Tag> { @Override public void populateLink() { if (linkId == null) { throw new RuntimeException("populateLink() was called but linkId is null"); } linkDisposable.clear(); Disposable disposable = repository.getLink(linkId) .subscribeOn(schedulerProvider.computation()) .observeOn(schedulerProvider.ui()) .subscribe(viewModel::populateLink, throwable -> { linkId = null; viewModel.showLinkNotFoundSnackbar(); }); linkDisposable.add(disposable); } @Inject AddEditLinkPresenter(
Repository repository, AddEditLinkContract.View view,
AddEditLinkContract.ViewModel viewModel, BaseSchedulerProvider schedulerProvider,
Settings settings, @Nullable @LinkId String linkId); @Override void subscribe(); @Override void unsubscribe(); @Override void loadTags(); @Override boolean isNewLink(); @Override void populateLink(); @Override void saveLink(
String linkLink, String linkName, boolean linkDisabled, List<Tag> linkTags); @Override void onClipboardChanged(int clipboardType, boolean force); @Override void onClipboardLinkExtraReady(boolean force); @Override void setShowFillInFormInfo(boolean show); @Override boolean isShowFillInFormInfo(); @Override void onTokenAdded(Tag token); @Override void onTokenRemoved(Tag token); @Override void onDuplicateRemoved(Tag token); }### Answer:
@Test public void populateLink_callsRepositoryAndUpdateViewOnSuccess() { final String linkId = defaultLink.getId(); when(repository.getLink(linkId)).thenReturn(Single.just(defaultLink)); AddEditLinkPresenter presenter = new AddEditLinkPresenter( repository, view, viewModel, schedulerProvider, settings, linkId); presenter.populateLink(); verify(repository).getLink(linkId); verify(viewModel).populateLink(any(Link.class)); }
@Test public void populateLink_callsRepositoryAndShowsWarningOnError() { final String linkId = defaultLink.getId(); when(repository.getLink(linkId)).thenReturn(Single.error(new NoSuchElementException())); AddEditLinkPresenter presenter = new AddEditLinkPresenter( repository, view, viewModel, schedulerProvider, settings, linkId); presenter.populateLink(); verify(repository).getLink(linkId); verify(viewModel, never()).populateLink(any(Link.class)); verify(viewModel).showLinkNotFoundSnackbar(); } |
### Question:
AddEditFavoritePresenter implements
AddEditFavoriteContract.Presenter, TokenCompleteTextView.TokenListener<Tag> { @Override public void loadTags() { tagsDisposable.clear(); Disposable disposable = repository.getTags() .subscribeOn(schedulerProvider.computation()) .toList() .observeOn(schedulerProvider.ui()) .subscribe(view::swapTagsCompletionViewItems, throwable -> { CommonUtils.logStackTrace(TAG_E, throwable); view.swapTagsCompletionViewItems(new ArrayList<>()); }); tagsDisposable.add(disposable); } @Inject AddEditFavoritePresenter(
Repository repository, AddEditFavoriteContract.View view,
AddEditFavoriteContract.ViewModel viewModel,
BaseSchedulerProvider schedulerProvider,
Settings settings, @Nullable @FavoriteId String favoriteId); @Override void subscribe(); @Override void unsubscribe(); @Override void loadTags(); @Override boolean isNewFavorite(); @Override void populateFavorite(); @Override void saveFavorite(String name, boolean andGate, List<Tag> tags); @Override void onClipboardChanged(int clipboardType, boolean force); @Override void onClipboardLinkExtraReady(boolean force); @Override void setShowFillInFormInfo(boolean show); @Override boolean isShowFillInFormInfo(); @Override void onTokenAdded(Tag tag); @Override void onTokenRemoved(Tag tag); @Override void onDuplicateRemoved(Tag tag); }### Answer:
@Test public void loadAllTagsFromRepository_loadsItIntoView() { List<Tag> tags = defaultFavorite.getTags(); assertNotNull(tags); when(repository.getTags()).thenReturn(Observable.fromIterable(tags)); presenter.loadTags(); verify(view).swapTagsCompletionViewItems(eq(tags)); }
@Test public void loadEmptyListOfTags_loadsEmptyListIntoView() { when(repository.getTags()).thenReturn(Observable.fromIterable(Collections.emptyList())); presenter.loadTags(); verify(view).swapTagsCompletionViewItems(tagListCaptor.capture()); assertEquals(tagListCaptor.getValue().size(), 0); } |
### Question:
AddEditFavoritePresenter implements
AddEditFavoriteContract.Presenter, TokenCompleteTextView.TokenListener<Tag> { @Override public void saveFavorite(String name, boolean andGate, List<Tag> tags) { if (isNewFavorite()) { createFavorite(name, andGate, tags); } else { updateFavorite(name, andGate, tags); } } @Inject AddEditFavoritePresenter(
Repository repository, AddEditFavoriteContract.View view,
AddEditFavoriteContract.ViewModel viewModel,
BaseSchedulerProvider schedulerProvider,
Settings settings, @Nullable @FavoriteId String favoriteId); @Override void subscribe(); @Override void unsubscribe(); @Override void loadTags(); @Override boolean isNewFavorite(); @Override void populateFavorite(); @Override void saveFavorite(String name, boolean andGate, List<Tag> tags); @Override void onClipboardChanged(int clipboardType, boolean force); @Override void onClipboardLinkExtraReady(boolean force); @Override void setShowFillInFormInfo(boolean show); @Override boolean isShowFillInFormInfo(); @Override void onTokenAdded(Tag tag); @Override void onTokenRemoved(Tag tag); @Override void onDuplicateRemoved(Tag tag); }### Answer:
@Test public void saveNewFavoriteToRepository_finishesActivity() { String favoriteName = defaultFavorite.getName(); boolean favoriteAndGate = defaultFavorite.isAndGate(); List<Tag> favoriteTags = defaultFavorite.getTags(); when(repository.saveFavorite(any(Favorite.class), eq(false))) .thenReturn(Observable.just(DataSource.ItemState.DEFERRED)); presenter.saveFavorite(favoriteName, favoriteAndGate, favoriteTags); verify(repository, never()).refreshFavorites(); verify(view).finishActivity(any(String.class)); }
@Test public void saveEmptyFavorite_showsEmptyError() { presenter.saveFavorite(defaultFavorite.getName(), false, new ArrayList<>()); presenter.saveFavorite(defaultFavorite.getName(), true, new ArrayList<>()); presenter.saveFavorite("", false, new ArrayList<>()); presenter.saveFavorite("", true, new ArrayList<>()); presenter.saveFavorite("", false, defaultFavorite.getTags()); presenter.saveFavorite("", true, defaultFavorite.getTags()); verify(viewModel, times(6)).showEmptyFavoriteSnackbar(); }
@Test public void saveExistingFavorite_finishesActivity() { String favoriteId = defaultFavorite.getId(); boolean favoriteAndGate = defaultFavorite.isAndGate(); String favoriteName = defaultFavorite.getName(); List<Tag> favoriteTags = defaultFavorite.getTags(); when(repository.saveFavorite(any(Favorite.class), eq(false))) .thenReturn(Observable.just(DataSource.ItemState.DEFERRED)); AddEditFavoritePresenter presenter = new AddEditFavoritePresenter( repository, view, viewModel, schedulerProvider, settings, favoriteId); presenter.saveFavorite(favoriteName, favoriteAndGate, favoriteTags); verify(repository, never()).refreshFavorites(); verify(view).finishActivity(eq(favoriteId)); }
@Test public void saveFavoriteWithExistedName_showsDuplicateError() { String favoriteId = defaultFavorite.getId(); boolean favoriteAndGate = defaultFavorite.isAndGate(); String favoriteName = defaultFavorite.getName(); List<Tag> favoriteTags = defaultFavorite.getTags(); when(repository.saveFavorite(any(Favorite.class), eq(false))) .thenReturn(Observable.error(new SQLiteConstraintException())); presenter.saveFavorite(favoriteName, favoriteAndGate, favoriteTags); verify(view, never()).finishActivity(eq(favoriteId)); verify(viewModel).showDuplicateKeyError(); } |
### Question:
IssueRegistry extends com.android.tools.lint.client.api.IssueRegistry { @Override public List<Issue> getIssues() { return Arrays.asList(InjectedFieldInJobNotTransientDetector.ISSUE); } @Override List<Issue> getIssues(); }### Answer:
@Test public void issues() throws Exception { assertThat(new IssueRegistry().getIssues()).contains( InjectedFieldInJobNotTransientDetector.ISSUE); } |
### Question:
ValidadorDniNie implements ConstraintValidator<ValidarDniNie, Asociado> { @Override public boolean isValid(Asociado asociado, ConstraintValidatorContext context) { if (asociado == null || asociado.getFechaNacimiento() == null) return true; context.disableDefaultConstraintViolation(); if (Strings.isNullOrEmpty(asociado.getDni())) { boolean mayorDeEdad = asociado.getFechaNacimiento().plus(18, ChronoUnit.YEARS).isBefore(LocalDate.now()); if (mayorDeEdad) { context.buildConstraintViolationWithTemplate(MSG_REQUERIDO_MAYOR_EDAD).addConstraintViolation(); return false; } else { return true; } } return validarDniNie(asociado.getDni(), context); } @Override void initialize(ValidarDniNie constraintAnnotation); @Override boolean isValid(Asociado asociado, ConstraintValidatorContext context); static boolean validarDniNie(String value, ConstraintValidatorContext context); static final String MSG_DIGITO_CONTROL; static final String DIGITO_CONTROL; }### Answer:
@Test public void si_la_fecha_de_nacimiento_del_asociado_es_nula_no_valida_el_dni() throws Exception { asociado.setDni("AAA"); asociado.setFechaNacimiento(null); assertTrue(validador.isValid(asociado, context)); }
@Test public void el_dni_es_requerido_cuando_el_asociado_es_mayor_de_18_años() throws Exception { asociado.setDni(null); asociado.setFechaNacimiento(LocalDate.now().minus(30, ChronoUnit.YEARS)); assertFalse(validador.isValid(asociado, context)); asociado.setDni(""); assertFalse(validador.isValid(asociado, context)); }
@Test public void el_dni_puede_ser_nulo_cuando_el_asociado_es_menor_de_18_años() throws Exception { asociado.setDni(null); asociado.setFechaNacimiento(LocalDate.now().minus(10, ChronoUnit.YEARS)); assertTrue(validador.isValid(asociado, context)); asociado.setDni(""); assertTrue(validador.isValid(asociado, context)); } |
### Question:
MarkLogicRepositoryFactory implements RepositoryFactory { @Override public Repository getRepository(RepositoryImplConfig config) throws RepositoryConfigException { MarkLogicRepository repo = null; MarkLogicRepositoryConfig cfg = (MarkLogicRepositoryConfig) config; if (cfg.getHost() != null && cfg.getPort() != 0) { repo = new MarkLogicRepository(cfg.getHost(),cfg.getPort(),cfg.getUser(),cfg.getPassword(),cfg.getAuth()); } else if (cfg.getHost() == null) { try { repo = new MarkLogicRepository(new URL(cfg.getQueryEndpointUrl())); } catch (MalformedURLException e) { logger.debug(e.getMessage()); throw new RepositoryConfigException(e.getMessage()); } }else{ throw new RepositoryConfigException("Invalid configuration class: " + config.getClass()); } return repo; } @Override /** * getter for repository type. * */ String getRepositoryType(); @Override /** * returns config * */ RepositoryImplConfig getConfig(); @Override /** * Instantiate and return repository object. * */ Repository getRepository(RepositoryImplConfig config); static final String REPOSITORY_TYPE; }### Answer:
@Test public void testGetRepository() throws Exception { MarkLogicRepositoryConfig config = new MarkLogicRepositoryConfig(); config.setHost(host); config.setPort(port); config.setUser(adminUser); config.setPassword(adminPassword); config.setAuth("DIGEST"); RepositoryFactory factory = new MarkLogicRepositoryFactory(); Assert.assertEquals("marklogic:MarkLogicRepository", factory.getRepositoryType()); Repository repo = factory.getRepository(config); repo.initialize(); Assert.assertTrue(repo.getConnection() instanceof MarkLogicRepositoryConnection); Repository otherrepo = factory.getRepository(config); otherrepo.initialize(); RepositoryConnection oconn = otherrepo.getConnection(); Assert.assertTrue(oconn instanceof MarkLogicRepositoryConnection); } |
### Question:
MarkLogicRepository extends AbstractRepository implements Repository,MarkLogicClientDependent { @Override public MarkLogicRepositoryConnection getConnection() throws RepositoryException { if (!isInitialized()) { throw new RepositoryException("MarkLogicRepository not initialized."); } return new MarkLogicRepositoryConnection(this, getMarkLogicClient(), quadMode); } MarkLogicRepository(URL connectionString); @Deprecated MarkLogicRepository(String host, int port, String user, String password, String auth); @Deprecated MarkLogicRepository(String host, int port, String user, String password, String database, String auth); MarkLogicRepository(String host, int port, DatabaseClientFactory.SecurityContext securityContext); MarkLogicRepository(String host, int port, String database, DatabaseClientFactory.SecurityContext securityContext); MarkLogicRepository(DatabaseClient databaseClient); ValueFactory getValueFactory(); void setValueFactory(ValueFactory f); @Override File getDataDir(); @Override void setDataDir(File dataDir); @Override boolean isWritable(); @Override MarkLogicRepositoryConnection getConnection(); @Override synchronized MarkLogicClient getMarkLogicClient(); @Override synchronized void setMarkLogicClient(MarkLogicClient client); boolean isQuadMode(); void setQuadMode(boolean quadMode); }### Answer:
@Test public void negativeTestRepo2() throws Exception { Repository rep = new MarkLogicRepository(host, port, new DatabaseClientFactory.DigestAuthContext(user, password)); rep.initialize(); rep.shutDown(); exception.expect(RepositoryException.class); exception.expectMessage("MarkLogicRepository not initialized."); @SuppressWarnings("unused") RepositoryConnection conn = rep.getConnection(); }
@Test public void TestRepoWithJavaAPIClientDatabaseClient() throws Exception { DatabaseClient databaseClient = DatabaseClientFactory.newClient(host, port, new DatabaseClientFactory.DigestAuthContext(user, password)); Repository rep = new MarkLogicRepository(databaseClient); rep.initialize(); Assert.assertTrue(rep instanceof Repository); RepositoryConnection conn = rep.getConnection(); Assert.assertTrue(conn instanceof RepositoryConnection); conn.close(); rep.shutDown(); }
@Test public void testMultipleReposWithDifferentUsers() throws RepositoryException, MalformedQueryException, UpdateExecutionException { readerRep.initialize(); MarkLogicRepositoryConnection testReaderCon = readerRep.getConnection(); exception.expect(Exception.class); testReaderCon.prepareUpdate("CREATE GRAPH <abc>").execute(); writerRep.initialize(); MarkLogicRepositoryConnection testWriterCon = writerRep.getConnection(); testWriterCon.prepareUpdate("CREATE GRAPH <abcdef10>").execute(); writerRep.shutDown(); readerRep.shutDown(); } |
### Question:
HelloWorld { public static String getHelloWorld() { return "Hello from Java!"; } static String getHelloWorld(); }### Answer:
@Test public void testHelloWorld() { assertEquals("Hello from Java!", HelloWorld.getHelloWorld()); } |
### Question:
ArrayUtils { public static <T> T[] concatenate(T[] firstArray, T[] secondArray) { if (firstArray == null) { return secondArray.clone(); } if (secondArray == null) { return firstArray.clone(); } T[] result = Arrays.copyOf(firstArray, firstArray.length + secondArray.length); System.arraycopy(secondArray, 0, result, firstArray.length, secondArray.length); return result; } private ArrayUtils(); static T[] concatenate(T[] firstArray, T[] secondArray); }### Answer:
@Test public void testConcatenate(){ String[] mStrings = new String[]{"Test 1","Test 2"}; String[] mStrings2 = new String[]{"Test 3","Test 4"}; String[] concat = concatenate(mStrings,mStrings2); assertArrayEquals(new String[]{"Test 1","Test 2","Test 3","Test 4"},concat); assertNotSame(mStrings,concatenate(mStrings,null)); assertNotSame(mStrings,concatenate(null,mStrings)); } |
### Question:
LiveboardImpl extends StopLocationImpl implements Liveboard, Serializable { public DateTime getSearchTime() { return mSearchTime; } LiveboardImpl(StopLocation station, VehicleStop[] stops, DateTime searchTime, LiveboardType type, QueryTimeDefinition timeDefinition); VehicleStop[] getStops(); DateTime getSearchTime(); QueryTimeDefinition getTimeDefinition(); LiveboardType getLiveboardType(); LiveboardImpl withStopsAppended(LiveboardImpl... other); void setPageInfo(NextDataPointer previous,
NextDataPointer current,
NextDataPointer next); @Override NextDataPointer getPreviousResultsPointer(); @Override NextDataPointer getCurrentResultsPointer(); @Override NextDataPointer getNextResultsPointer(); }### Answer:
@Test void getSearchTime_shouldReturnCorrectValue() { DateTime mDateTime = DateTime.now(); StopLocation station = Mockito.mock(StopLocation.class); Mockito.when(station.getHafasId()).thenReturn("008814001"); VehicleStop stop = Mockito.mock(VehicleStop.class); VehicleStop[] stops = new VehicleStop[]{stop}; Liveboard instance = new LiveboardImpl(station, stops, mDateTime, DEPARTURES, EQUAL_OR_LATER); assertEquals(mDateTime, instance.getSearchTime()); } |
### Question:
LiveboardImpl extends StopLocationImpl implements Liveboard, Serializable { public QueryTimeDefinition getTimeDefinition() { return mTimeDefinition; } LiveboardImpl(StopLocation station, VehicleStop[] stops, DateTime searchTime, LiveboardType type, QueryTimeDefinition timeDefinition); VehicleStop[] getStops(); DateTime getSearchTime(); QueryTimeDefinition getTimeDefinition(); LiveboardType getLiveboardType(); LiveboardImpl withStopsAppended(LiveboardImpl... other); void setPageInfo(NextDataPointer previous,
NextDataPointer current,
NextDataPointer next); @Override NextDataPointer getPreviousResultsPointer(); @Override NextDataPointer getCurrentResultsPointer(); @Override NextDataPointer getNextResultsPointer(); }### Answer:
@Test void getTimeDefinition_shouldReturnCorrectValue() { DateTime mDateTime = DateTime.now(); StopLocation station = Mockito.mock(StopLocation.class); Mockito.when(station.getHafasId()).thenReturn("008814001"); VehicleStop stop = Mockito.mock(VehicleStop.class); VehicleStop[] stops = new VehicleStop[]{stop}; Liveboard departing = new LiveboardImpl(station, stops, mDateTime, DEPARTURES, EQUAL_OR_LATER); Liveboard arriving = new LiveboardImpl(station, stops, mDateTime, DEPARTURES, QueryTimeDefinition.EQUAL_OR_EARLIER); assertEquals(EQUAL_OR_LATER, departing.getTimeDefinition()); assertEquals(QueryTimeDefinition.EQUAL_OR_EARLIER, arriving.getTimeDefinition()); } |
### Question:
LiveboardImpl extends StopLocationImpl implements Liveboard, Serializable { public LiveboardType getLiveboardType() { return mType; } LiveboardImpl(StopLocation station, VehicleStop[] stops, DateTime searchTime, LiveboardType type, QueryTimeDefinition timeDefinition); VehicleStop[] getStops(); DateTime getSearchTime(); QueryTimeDefinition getTimeDefinition(); LiveboardType getLiveboardType(); LiveboardImpl withStopsAppended(LiveboardImpl... other); void setPageInfo(NextDataPointer previous,
NextDataPointer current,
NextDataPointer next); @Override NextDataPointer getPreviousResultsPointer(); @Override NextDataPointer getCurrentResultsPointer(); @Override NextDataPointer getNextResultsPointer(); }### Answer:
@Test void getLiveboardType_shouldReturnCorrectValue() { DateTime mDateTime = DateTime.now(); StopLocation station = Mockito.mock(StopLocation.class); Mockito.when(station.getHafasId()).thenReturn("008814001"); VehicleStop stop = Mockito.mock(VehicleStop.class); VehicleStop[] stops = new VehicleStop[]{stop}; Liveboard departing = new LiveboardImpl(station, stops, mDateTime, DEPARTURES, EQUAL_OR_LATER); Liveboard arriving = new LiveboardImpl(station, stops, mDateTime, LiveboardType.ARRIVALS, EQUAL_OR_LATER); assertEquals(DEPARTURES, departing.getLiveboardType()); assertEquals(LiveboardType.ARRIVALS, arriving.getLiveboardType()); } |
### Question:
Base32Utils { public static String encode(byte[] input) { byte b; int symbol; int carry = 0; int shift = 3; StringBuilder sb = new StringBuilder(); for (byte value : input) { b = value; symbol = carry | (b >> shift); sb.append(BASE32_CHARS[symbol & 0x1f]); if (shift > 5) { shift -= 5; symbol = b >> shift; sb.append(BASE32_CHARS[symbol & 0x1f]); } shift = 5 - shift; carry = b << shift; shift = 8 - shift; } if (shift != 3) { sb.append(BASE32_CHARS[carry & 0x1f]); } return sb.toString(); } static String encode(byte[] input); }### Answer:
@Test public void test() { assertEquals("MY", Base32Utils.encode("f".getBytes())); assertEquals("MZXQ", Base32Utils.encode("fo".getBytes())); assertEquals("MZXW6", Base32Utils.encode("foo".getBytes())); assertEquals("MZXW6YQ", Base32Utils.encode("foob".getBytes())); assertEquals("MZXW6YTB", Base32Utils.encode("fooba".getBytes())); assertEquals("MZXW6YTBOI", Base32Utils.encode("foobar".getBytes())); } |
### Question:
UsersResource { @Decision(POST) public User doPost(UserCreateRequest createRequest, ActionRecord actionRecord, UserPermissionPrincipal principal, RestContext context, EntityManager em) { User user = converter.createFrom(createRequest, User.class); UserProfileService userProfileService = new UserProfileService(em); List<UserProfileValue> userProfileValues = userProfileService .convertToUserProfileValues(createRequest.getUserProfiles()); user.setUserProfileValues(userProfileValues.stream() .peek(v -> v.setUser(user)) .collect(Collectors.toList())); List<UserProfileVerification> profileVerifications = config.getVerificationPolicy().isVerificationEnabledAtCreateUser() ? userProfileService .createProfileVerification(userProfileValues).stream() .peek(v -> v.setUser(user)) .collect(Collectors.toList()) : Collections.emptyList(); user.setWriteProtected(false); context.putValue(user); config.getHookRepo().runHook(HookPoint.BEFORE_CREATE_USER, context); EntityTransactionManager tm = new EntityTransactionManager(em); tm.required(() -> { em.persist(user); profileVerifications.forEach(em::persist); config.getHookRepo().runHook(HookPoint.AFTER_CREATE_USER, context); }); actionRecord.setActionType(ActionType.USER_CREATED); actionRecord.setActor(principal.getName()); actionRecord.setDescription(user.getAccount()); return user; } @Decision(value = MALFORMED, method = "POST") Problem validateUserCreateRequest(UserCreateRequest createRequest, RestContext context, EntityManager em); @Decision(value = MALFORMED, method = "GET") Problem validateUserSearchParams(Parameters params, RestContext context); @Decision(AUTHORIZED) boolean isAuthorized(UserPermissionPrincipal principal); @Decision(value = ALLOWED, method= "GET") boolean isGetAllowed(UserPermissionPrincipal principal); @Decision(value = ALLOWED, method= "POST") boolean isPostAllowed(UserPermissionPrincipal principal); @Decision(value = CONFLICT, method = "POST") boolean conflict(UserCreateRequest createRequest,
RestContext context,
EntityManager em); @Decision(HANDLE_OK) List<User> handleOk(UserSearchParams params, UserPermissionPrincipal principal, EntityManager em); @Decision(POST) User doPost(UserCreateRequest createRequest,
ActionRecord actionRecord,
UserPermissionPrincipal principal,
RestContext context,
EntityManager em); }### Answer:
@Test void post() { UsersResource resource = new UsersResource(); ComponentInjector injector = new ComponentInjector( Map.of("converter", system.getComponent("converter"), "config", system.getComponent("config"))); injector.inject(resource); HttpRequest request = builder(new DefaultHttpRequest()) .set(HttpRequest::setRequestMethod, "POST") .build(); RestContext context = new RestContext(new DefaultResource(), request); UserCreateRequest user = builder(new UserCreateRequest()) .set(UserCreateRequest::setAccount, "fuga") .build(); EntityManager em = MockFactory.createEntityManagerMock(); ActionRecord actionRecord = new ActionRecord(); UserPermissionPrincipal principal = new UserPermissionPrincipal(1L, "admin", Map.of(), Set.of()); resource.doPost(user, actionRecord, principal, context, em); } |
### Question:
UsersResource { @Decision(value = MALFORMED, method = "POST") public Problem validateUserCreateRequest(UserCreateRequest createRequest, RestContext context, EntityManager em) { if (createRequest == null) { return builder(Problem.valueOf(400, "request is empty")) .set(Problem::setType, BouncrProblem.MALFORMED.problemUri()) .build(); } Set<ConstraintViolation<UserCreateRequest>> violations = validator.validate(createRequest); Problem problem = builder(Problem.fromViolations(violations)) .set(Problem::setType, BouncrProblem.MALFORMED.problemUri()) .build(); config.getHookRepo().runHook(HookPoint.BEFORE_VALIDATE_USER_PROFILES, createRequest.getUserProfiles()); UserProfileService userProfileService = new UserProfileService(em); Set<Problem.Violation> profileViolations = userProfileService.validateUserProfile(createRequest.getUserProfiles()); problem.getViolations().addAll(profileViolations); if (problem.getViolations().isEmpty()) { context.putValue(createRequest); } return problem.getViolations().isEmpty() ? null : problem; } @Decision(value = MALFORMED, method = "POST") Problem validateUserCreateRequest(UserCreateRequest createRequest, RestContext context, EntityManager em); @Decision(value = MALFORMED, method = "GET") Problem validateUserSearchParams(Parameters params, RestContext context); @Decision(AUTHORIZED) boolean isAuthorized(UserPermissionPrincipal principal); @Decision(value = ALLOWED, method= "GET") boolean isGetAllowed(UserPermissionPrincipal principal); @Decision(value = ALLOWED, method= "POST") boolean isPostAllowed(UserPermissionPrincipal principal); @Decision(value = CONFLICT, method = "POST") boolean conflict(UserCreateRequest createRequest,
RestContext context,
EntityManager em); @Decision(HANDLE_OK) List<User> handleOk(UserSearchParams params, UserPermissionPrincipal principal, EntityManager em); @Decision(POST) User doPost(UserCreateRequest createRequest,
ActionRecord actionRecord,
UserPermissionPrincipal principal,
RestContext context,
EntityManager em); }### Answer:
@Test void validate() { ComponentInjector injector = new ComponentInjector( Map.of("converter", system.getComponent("converter"), "validator", system.getComponent("validator"), "config", system.getComponent("config"))); UsersResource resource = injector.inject(new UsersResource()); UserCreateRequest createRequest = builder(new UserCreateRequest()) .set(UserCreateRequest::setAccount, "fuga") .build(); HttpRequest request = builder(new DefaultHttpRequest()) .set(HttpRequest::setRequestMethod, "POST") .build(); EntityManager em = MockFactory.createEntityManagerMock(); Problem problem = resource.validateUserCreateRequest(createRequest, new RestContext(new DefaultResource(), request), em); assertThat(problem).isNull(); } |
### Question:
RolePermissionsResource { @Decision(POST) public RolePermissionsRequest create(RolePermissionsRequest createRequest, Role role, EntityManager em) { CriteriaBuilder cb = em.getCriteriaBuilder(); CriteriaQuery<Permission> query = cb.createQuery(Permission.class); Root<Permission> permissionRoot = query.from(Permission.class); query.where(permissionRoot.get("name").in(createRequest)); List<Permission> permissions = em.createQuery(query) .setHint("javax.persistence.cache.storeMode", CacheStoreMode.REFRESH) .getResultList(); EntityTransactionManager tx = new EntityTransactionManager(em); tx.required(() -> { HashSet<Permission> rolePermissions = new HashSet<>(role.getPermissions()); rolePermissions.addAll(permissions); role.setPermissions(new ArrayList<>(rolePermissions)); }); return createRequest; } @Decision(AUTHORIZED) boolean isAuthorized(UserPermissionPrincipal principal); @Decision(value = ALLOWED, method= "GET") boolean isGetAllowed(UserPermissionPrincipal principal); @Decision(value = ALLOWED, method= { "POST", "DELETE" }) boolean isModifyAllowed(UserPermissionPrincipal principal); @Decision(EXISTS) boolean exists(Parameters params, RestContext context, EntityManager em); @Decision(HANDLE_OK) List<Permission> list(Role role, EntityManager em); @Decision(POST) RolePermissionsRequest create(RolePermissionsRequest createRequest, Role role, EntityManager em); @Decision(DELETE) RolePermissionsRequest delete(RolePermissionsRequest deleteRequest, Role role, EntityManager em); }### Answer:
@Test void create() { TypedQuery query = mock(TypedQuery.class); Mockito.when(query.getResultList()).thenReturn( List.of( builder(new Permission()) .set(Permission::setId, 2L) .set(Permission::setName, "test2").build(), builder(new Permission()) .set(Permission::setId, 3L) .set(Permission::setName, "test3").build() ) ); final EntityManager em = MockFactory.createEntityManagerMock(query); final RolePermissionsResource resource = new RolePermissionsResource(); final RolePermissionsRequest RolePermissionsRequest = new RolePermissionsRequest(); RolePermissionsRequest.addAll(Arrays.asList("test2", "test3")); final List<Permission> Permissions = List.of( builder(new Permission()) .set(Permission::setId, 1L) .set(Permission::setName, "test1").build(), builder(new Permission()) .set(Permission::setId, 2L) .set(Permission::setName, "test2").build() ); final Role role = builder(new Role()) .set(Role::setPermissions, Permissions) .build(); resource.create(RolePermissionsRequest, role, em); assertThat(role.getPermissions()).containsExactly( builder(new Permission()).set(Permission::setId, 1L) .set(Permission::setName, "test1").build(), builder(new Permission()).set(Permission::setId, 2L) .set(Permission::setName, "test2").build(), builder(new Permission()).set(Permission::setId, 3L) .set(Permission::setName, "test3").build() ); } |
### Question:
RolePermissionsResource { @Decision(DELETE) public RolePermissionsRequest delete(RolePermissionsRequest deleteRequest, Role role, EntityManager em) { CriteriaBuilder cb = em.getCriteriaBuilder(); CriteriaQuery<Permission> query = cb.createQuery(Permission.class); Root<Permission> permissionRoot = query.from(Permission.class); query.where(permissionRoot.get("name").in(deleteRequest)); List<Permission> permissions = em.createQuery(query) .setHint("javax.persistence.cache.storeMode", CacheStoreMode.REFRESH) .getResultList(); EntityTransactionManager tx = new EntityTransactionManager(em); tx.required(() -> { HashSet<Permission> rolePermissions = new HashSet<>(role.getPermissions()); rolePermissions.removeAll(permissions); role.setPermissions(new ArrayList<>(rolePermissions)); }); return deleteRequest; } @Decision(AUTHORIZED) boolean isAuthorized(UserPermissionPrincipal principal); @Decision(value = ALLOWED, method= "GET") boolean isGetAllowed(UserPermissionPrincipal principal); @Decision(value = ALLOWED, method= { "POST", "DELETE" }) boolean isModifyAllowed(UserPermissionPrincipal principal); @Decision(EXISTS) boolean exists(Parameters params, RestContext context, EntityManager em); @Decision(HANDLE_OK) List<Permission> list(Role role, EntityManager em); @Decision(POST) RolePermissionsRequest create(RolePermissionsRequest createRequest, Role role, EntityManager em); @Decision(DELETE) RolePermissionsRequest delete(RolePermissionsRequest deleteRequest, Role role, EntityManager em); }### Answer:
@Test void delete() { TypedQuery query = mock(TypedQuery.class); Mockito.when(query.getResultList()).thenReturn( List.of( builder(new Permission()).set(Permission::setId, 1L).set(Permission::setName, "test1").build(), builder(new Permission()).set(Permission::setId, 3L).set(Permission::setName, "test3").build() ) ); final EntityManager em = MockFactory.createEntityManagerMock(query); final RolePermissionsResource resource = new RolePermissionsResource(); final RolePermissionsRequest RolePermissionsRequest = new RolePermissionsRequest(); RolePermissionsRequest.addAll(Arrays.asList("test1", "test3")); final List<Permission> permissions = List.of( builder(new Permission()).set(Permission::setId, 1L).set(Permission::setName, "test1").build(), builder(new Permission()).set(Permission::setId, 2L).set(Permission::setName, "test2").build(), builder(new Permission()).set(Permission::setId, 3L).set(Permission::setName, "test3").build() ); final Role role = builder(new Role()) .set(Role::setPermissions, permissions) .build(); resource.delete(RolePermissionsRequest, role, em); assertThat(role.getPermissions()).containsExactly( builder(new Permission()).set(Permission::setId, 2L).set(Permission::setName, "test2").build() ); } |
### Question:
GroupUsersResource { @Decision(POST) public GroupUsersRequest create(GroupUsersRequest createRequest, Group group, EntityManager em) { CriteriaBuilder cb = em.getCriteriaBuilder(); CriteriaQuery<User> query = cb.createQuery(User.class); Root<User> userRoot = query.from(User.class); query.where(userRoot.get("account").in(createRequest)); List<User> users = em.createQuery(query) .setHint("javax.persistence.cache.storeMode", CacheStoreMode.REFRESH) .getResultList(); EntityTransactionManager tx = new EntityTransactionManager(em); tx.required(() -> { HashSet<User> groupUsers = new HashSet<>(group.getUsers()); groupUsers.addAll(users); group.setUsers(new ArrayList<>(groupUsers)); }); return createRequest; } @Decision(value = MALFORMED, method = {"POST", "DELETE"}) Problem vaidateCreateRequest(GroupUsersRequest createRequest, RestContext context); @Decision(AUTHORIZED) boolean isAuthorized(UserPermissionPrincipal principal); @Decision(value = ALLOWED, method= "GET") boolean isGetAllowed(UserPermissionPrincipal principal); @Decision(value = ALLOWED, method= { "POST", "DELETE" }) boolean isModifyAllowed(UserPermissionPrincipal principal); @Decision(PROCESSABLE) boolean processable(Parameters params, RestContext context, EntityManager em); @Decision(HANDLE_OK) List<User> list(Group group, EntityManager em); @Decision(POST) GroupUsersRequest create(GroupUsersRequest createRequest, Group group, EntityManager em); @Decision(DELETE) GroupUsersRequest delete(GroupUsersRequest createRequest, Group group, EntityManager em); }### Answer:
@Test void create() { TypedQuery query = mock(TypedQuery.class); Mockito.when(query.getResultList()).thenReturn( List.of( builder(new User()).set(User::setId, 2L).set(User::setAccount, "test2").build(), builder(new User()).set(User::setId, 3L).set(User::setAccount, "test3").build() ) ); final EntityManager em = MockFactory.createEntityManagerMock(query); final GroupUsersResource resource = new GroupUsersResource(); final GroupUsersRequest groupUsersRequest = new GroupUsersRequest(); groupUsersRequest.addAll(Arrays.asList("test2", "test3")); final List<User> users = List.of( builder(new User()).set(User::setId, 1L).set(User::setAccount, "test1").build(), builder(new User()).set(User::setId, 2L).set(User::setAccount, "test2").build() ); final Group group = builder(new Group()) .set(Group::setUsers, users) .build(); resource.create(groupUsersRequest, group, em); assertThat(group.getUsers()).containsExactly( builder(new User()).set(User::setId, 1L).set(User::setAccount, "test1").build(), builder(new User()).set(User::setId, 2L).set(User::setAccount, "test2").build(), builder(new User()).set(User::setId, 3L).set(User::setAccount, "test3").build() ); } |
### Question:
GroupUsersResource { @Decision(DELETE) public GroupUsersRequest delete(GroupUsersRequest createRequest, Group group, EntityManager em) { CriteriaBuilder cb = em.getCriteriaBuilder(); CriteriaQuery<User> query = cb.createQuery(User.class); Root<User> userRoot = query.from(User.class); query.where(userRoot.get("account").in(createRequest)); List<User> users = em.createQuery(query) .setHint("javax.persistence.cache.storeMode", CacheStoreMode.REFRESH) .getResultList(); EntityTransactionManager tx = new EntityTransactionManager(em); tx.required(() -> { HashSet<User> groupUsers = new HashSet<>(group.getUsers()); groupUsers.removeAll(users); group.setUsers(new ArrayList<>(groupUsers)); }); return createRequest; } @Decision(value = MALFORMED, method = {"POST", "DELETE"}) Problem vaidateCreateRequest(GroupUsersRequest createRequest, RestContext context); @Decision(AUTHORIZED) boolean isAuthorized(UserPermissionPrincipal principal); @Decision(value = ALLOWED, method= "GET") boolean isGetAllowed(UserPermissionPrincipal principal); @Decision(value = ALLOWED, method= { "POST", "DELETE" }) boolean isModifyAllowed(UserPermissionPrincipal principal); @Decision(PROCESSABLE) boolean processable(Parameters params, RestContext context, EntityManager em); @Decision(HANDLE_OK) List<User> list(Group group, EntityManager em); @Decision(POST) GroupUsersRequest create(GroupUsersRequest createRequest, Group group, EntityManager em); @Decision(DELETE) GroupUsersRequest delete(GroupUsersRequest createRequest, Group group, EntityManager em); }### Answer:
@Test void delete() { TypedQuery query = mock(TypedQuery.class); Mockito.when(query.getResultList()).thenReturn( List.of( builder(new User()).set(User::setId, 1L).set(User::setAccount, "test1").build(), builder(new User()).set(User::setId, 3L).set(User::setAccount, "test3").build() ) ); final EntityManager em = MockFactory.createEntityManagerMock(query); final GroupUsersResource resource = new GroupUsersResource(); final GroupUsersRequest groupUsersRequest = new GroupUsersRequest(); groupUsersRequest.addAll(Arrays.asList("test1", "test3")); final List<User> users = List.of( builder(new User()).set(User::setId, 1L).set(User::setAccount, "test1").build(), builder(new User()).set(User::setId, 2L).set(User::setAccount, "test2").build(), builder(new User()).set(User::setId, 3L).set(User::setAccount, "test3").build() ); final Group group = builder(new Group()) .set(Group::setUsers, users) .build(); resource.delete(groupUsersRequest, group, em); assertThat(group.getUsers()).containsExactly( builder(new User()).set(User::setId, 2L).set(User::setAccount, "test2").build() ); } |
### Question:
PasswordUtils { public static byte[] pbkdf2(String password, String salt, int iterations) { PBEKeySpec keySpec = new PBEKeySpec(password.toCharArray(), salt.getBytes(), iterations, 2048); try { SecretKeyFactory keyFactory = SecretKeyFactory.getInstance("PBKDF2WithHmacSHA384"); SecretKey secretKey = keyFactory.generateSecret(keySpec); return secretKey.getEncoded(); } catch (NoSuchAlgorithmException e) { throw new UnreachableException(e); } catch (InvalidKeySpecException e) { throw new MisconfigurationException("core.INVALID_KEY", e); } } static byte[] pbkdf2(String password, String salt, int iterations); }### Answer:
@Test public void test() { byte[] hash = PasswordUtils.pbkdf2("password", "salt", 100); System.out.println(hash.length); } |
### Question:
User implements Serializable { public void setUserLock(UserLock userLock) { this.userLock = userLock; } Long getId(); void setId(Long id); String getAccount(); void setAccount(String account); String getAccountLower(); void setAccountLower(String accountLower); Boolean getWriteProtected(); void setWriteProtected(Boolean writeProtected); List<Group> getGroups(); void setGroups(List<Group> groups); List<UserProfileValue> getUserProfileValues(); void setUserProfileValues(List<UserProfileValue> userProfileValues); @JsonAnyGetter Map<String, Object> getUserProfiles(); UserLock getUserLock(); void setUserLock(UserLock userLock); OtpKey getOtpKey(); void setOtpKey(OtpKey otpKey); PasswordCredential getPasswordCredential(); void setPasswordCredential(PasswordCredential passwordCredential); List<OidcUser> getOidcUsers(); void setOidcUsers(List<OidcUser> oidcUsers); @JsonProperty("oidc_providers") @Transient @JsonInclude(JsonInclude.Include.NON_EMPTY) List<String> getOidcProviders(); List<String> getPermissions(); void setPermissions(List<String> permissions); List<String> getUnverifiedProfiles(); void setUnverifiedProfiles(List<String> unverifiedProfiles); @Override boolean equals(Object obj); @Override int hashCode(); @Override String toString(); }### Answer:
@Test void cyclicSerialize() { ObjectMapper mapper = new ObjectMapper(); User user = builder(new User()) .set(User::setId, 1L) .set(User::setAccount, "test") .set(User::setGroups, new IndirectList<>()) .build(); UserLock userLock = builder(new UserLock()) .set(UserLock::setUser, user) .set(UserLock::setLockedAt, LocalDateTime.now()) .set(UserLock::setLockLevel, LockLevel.LOOSE) .build(); user.setUserLock(userLock); assertThatCode(() -> { mapper.writerFor(User.class).writeValueAsString(user); mapper.writerFor(UserLock.class).writeValueAsString(userLock); }).doesNotThrowAnyException(); } |
### Question:
StoreProvider extends SystemComponent<StoreProvider> { public KeyValueStore getStore(StoreType storeType) { switch(storeType) { case BOUNCR_TOKEN: return bouncrTokenStore; case AUTHORIZATION_CODE: return authorizationCodeStore; case ACCESS_TOKEN: return accessTokenStore; case OIDC_SESSION: return oidcSessionStore; default: throw new IllegalArgumentException(storeType + " is unknown"); } } KeyValueStore getStore(StoreType storeType); }### Answer:
@Test void test() { StoreProvider provider = system.getComponent("storeProvider", StoreProvider.class); KeyValueStore store = provider.getStore(StoreProvider.StoreType.BOUNCR_TOKEN); store.write("A", "B"); } |
### Question:
Flake extends SystemComponent { public synchronized BigInteger generateId() { ByteBuffer buf = ByteBuffer.allocate(16); long current = clock.millis(); if (current != lastTime) { lastTime = current; sequence = 0; } else { sequence++; } return new BigInteger(buf.putLong(lastTime).put(macAddress).putShort((short)sequence) .array()); } synchronized BigInteger generateId(); }### Answer:
@Test void sortedOrder() { Flake flake = system.getComponent("flake"); BigInteger[] ids = new BigInteger[100]; for (int i=0; i<100; i++) { ids[i] = flake.generateId(); } for (int i=0; i<99; i++) { assertThat(ids[i]).isLessThan(ids[i+1]); } } |
### Question:
HealthCheckHandler implements HttpHandler { @Override public void handleRequest(HttpServerExchange exchange) throws Exception { if (exchange.isInIoThread()) { exchange.dispatch(this); return; } HealthCheckResponse response = HealthCheckResponse.builder() .name("bouncr-proxy") .up() .build(); exchange.setStatusCode(200); exchange.getResponseSender().send(mapper.writeValueAsString(response)); } HealthCheckHandler(); @Override void handleRequest(HttpServerExchange exchange); }### Answer:
@Test void healthCheck_Normal() throws Exception { HttpServerExchange exchange = mock(HttpServerExchange.class); Sender sender = mock(Sender.class); given(exchange.getResponseSender()).willReturn(sender); HealthCheckHandler handler = new HealthCheckHandler(); handler.handleRequest(exchange); verify(sender).send(anyString()); } |
### Question:
PasswordCredentialResource { @Decision(value=PROCESSABLE, method="POST") public boolean userProcessableInPost(PasswordCredentialCreateRequest createRequest, RestContext context, EntityManager em) { return findUserByAccount(createRequest.getAccount(), em) .map(user -> { context.putValue(user); return user; }).isPresent(); } @Decision(value = MALFORMED, method = "POST") Problem validateCreateRequest(PasswordCredentialCreateRequest createRequest, RestContext context, EntityManager em); @Decision(value = MALFORMED, method = "PUT") Problem validateUpdateRequest(PasswordCredentialUpdateRequest updateRequest, RestContext context, EntityManager em); @Decision(value = MALFORMED, method = "DELETE") Problem validateDeleteRequest(PasswordCredentialUpdateRequest deleteRequest, RestContext context, EntityManager em); @Decision(value = AUTHORIZED, method = {"POST", "DELETE"}) boolean isAuthorized(UserPermissionPrincipal principal); @Decision(value = ALLOWED, method = "POST") boolean isPostAllowed(UserPermissionPrincipal principal, PasswordCredentialCreateRequest createRequest); @Decision(value = ALLOWED, method = "PUT") boolean isPutAllowed(UserPermissionPrincipal principal, PasswordCredentialUpdateRequest updateRequest); @Decision(value = ALLOWED, method = "DELETE") boolean isDeleteAllowed(UserPermissionPrincipal principal, PasswordCredentialDeleteRequest deleteRequest); @Decision(value=PROCESSABLE, method="POST") boolean userProcessableInPost(PasswordCredentialCreateRequest createRequest, RestContext context, EntityManager em); @Decision(value=PROCESSABLE, method="PUT") boolean userProcessableInPut(PasswordCredentialUpdateRequest updateRequest, RestContext context, EntityManager em); @Decision(POST) PasswordCredential create(PasswordCredentialCreateRequest createRequest,
User user,
UserPermissionPrincipal principal,
ActionRecord actionRecord,
RestContext context,
EntityManager em); @Decision(PUT) PasswordCredential update(PasswordCredentialUpdateRequest updateRequest,
User user,
UserPermissionPrincipal principal,
ActionRecord actionRecord,
RestContext context,
EntityManager em); @Decision(DELETE) Void delete(UserPermissionPrincipal principal,
ActionRecord actionRecord,
RestContext context,
EntityManager em); }### Answer:
@Test void userProcessableInPost_Successful() { TypedQuery query = mock(TypedQuery.class); User user = builder(new User()) .set(User::setId, 1L) .set(User::setAccount, "test_user") .build(); when(query.getResultStream()).thenReturn(Stream.of(user)); final EntityManager em = MockFactory.createEntityManagerMock(query); HttpRequest request = builder(new DefaultHttpRequest()) .set(HttpRequest::setRequestMethod, "POST") .build(); RestContext context = new RestContext(new DefaultResource(), request); PasswordCredentialResource resource = new PasswordCredentialResource(); PasswordCredentialCreateRequest createRequest = new PasswordCredentialCreateRequest(); createRequest.setAccount("test_user"); createRequest.setPassword("pass1234"); ComponentInjector injector = new ComponentInjector( Map.of("config", system.getComponent("config"), "validator", system.getComponent("validator"))); injector.inject(resource); boolean ret = resource.userProcessableInPost(createRequest, context, em); assertThat(ret).isTrue(); } |
### Question:
PasswordCredentialResource { @Decision(value=PROCESSABLE, method="PUT") public boolean userProcessableInPut(PasswordCredentialUpdateRequest updateRequest, RestContext context, EntityManager em) { return findUserByAccount(updateRequest.getAccount(), em) .map(user -> { context.putValue(user); return user; }) .filter(user -> user.getPasswordCredential() != null) .filter(user -> Arrays.equals(user.getPasswordCredential().getPassword(), PasswordUtils.pbkdf2(updateRequest.getOldPassword(), user.getPasswordCredential().getSalt(), 100)) ) .isPresent(); } @Decision(value = MALFORMED, method = "POST") Problem validateCreateRequest(PasswordCredentialCreateRequest createRequest, RestContext context, EntityManager em); @Decision(value = MALFORMED, method = "PUT") Problem validateUpdateRequest(PasswordCredentialUpdateRequest updateRequest, RestContext context, EntityManager em); @Decision(value = MALFORMED, method = "DELETE") Problem validateDeleteRequest(PasswordCredentialUpdateRequest deleteRequest, RestContext context, EntityManager em); @Decision(value = AUTHORIZED, method = {"POST", "DELETE"}) boolean isAuthorized(UserPermissionPrincipal principal); @Decision(value = ALLOWED, method = "POST") boolean isPostAllowed(UserPermissionPrincipal principal, PasswordCredentialCreateRequest createRequest); @Decision(value = ALLOWED, method = "PUT") boolean isPutAllowed(UserPermissionPrincipal principal, PasswordCredentialUpdateRequest updateRequest); @Decision(value = ALLOWED, method = "DELETE") boolean isDeleteAllowed(UserPermissionPrincipal principal, PasswordCredentialDeleteRequest deleteRequest); @Decision(value=PROCESSABLE, method="POST") boolean userProcessableInPost(PasswordCredentialCreateRequest createRequest, RestContext context, EntityManager em); @Decision(value=PROCESSABLE, method="PUT") boolean userProcessableInPut(PasswordCredentialUpdateRequest updateRequest, RestContext context, EntityManager em); @Decision(POST) PasswordCredential create(PasswordCredentialCreateRequest createRequest,
User user,
UserPermissionPrincipal principal,
ActionRecord actionRecord,
RestContext context,
EntityManager em); @Decision(PUT) PasswordCredential update(PasswordCredentialUpdateRequest updateRequest,
User user,
UserPermissionPrincipal principal,
ActionRecord actionRecord,
RestContext context,
EntityManager em); @Decision(DELETE) Void delete(UserPermissionPrincipal principal,
ActionRecord actionRecord,
RestContext context,
EntityManager em); }### Answer:
@Test void userProcessableInPut_Successful() { TypedQuery query = mock(TypedQuery.class); PasswordCredential credential = builder(new PasswordCredential()) .set(PasswordCredential::setPassword, PasswordUtils.pbkdf2("pass1234", "saltsalt", 100)) .set(PasswordCredential::setSalt, "saltsalt") .build(); User user = builder(new User()) .set(User::setId, 1L) .set(User::setAccount, "test_user") .set(User::setPasswordCredential, credential) .build(); when(query.getResultStream()).thenReturn(Stream.of(user)); final EntityManager em = MockFactory.createEntityManagerMock(query); HttpRequest request = builder(new DefaultHttpRequest()) .set(HttpRequest::setRequestMethod, "POST") .build(); RestContext context = new RestContext(new DefaultResource(), request); PasswordCredentialResource resource = new PasswordCredentialResource(); PasswordCredentialUpdateRequest updateRequest = builder(new PasswordCredentialUpdateRequest()) .set(PasswordCredentialUpdateRequest::setAccount, "test_user") .set(PasswordCredentialUpdateRequest::setOldPassword, "pass1234") .set(PasswordCredentialUpdateRequest::setNewPassword, "pass5678") .build(); ComponentInjector injector = new ComponentInjector( Map.of("config", system.getComponent("config"), "validator", system.getComponent("validator"))); injector.inject(resource); boolean ret = resource.userProcessableInPut(updateRequest, context, em); assertThat(ret).isTrue(); } |
### Question:
ScheduledTasks { @Scheduled(fixedRate = 5000) public void reportCurrentTime() { log.info("The time is now {}", dateFormat.format(new Date())); } @Scheduled(fixedRate = 5000) void reportCurrentTime(); }### Answer:
@Test public void reportCurrentTime() { await().atMost(Duration.TEN_SECONDS).untilAsserted(() -> { verify(tasks, atLeast(2)).reportCurrentTime(); }); } |
### Question:
TopicLogger implements Plugin, TopicListener { public TopicLogger withExcludeTopics(Topic... excludeTopics) { this.excludeTopics = excludeTopics; return this; } TopicLogger withLogger(Logger logger); TopicLogger withExcludeTopics(Topic... excludeTopics); @Override void onBuild(EdgeNodeBuilder builder); @Override void onRun(EdgeNode edge); @Override void close(); @Override void onOpen(EdgeNexus nexus); @Override void onClose(EdgeNexus nexus); @Override void onBind(EdgeNexus nexus, BindFrame bind, BindResponseFrame bindRes); @Override void onPublish(EdgeNexus nexus, PublishTextFrame pub); @Override void onPublish(EdgeNexus nexus, PublishBinaryFrame pub); @Override String toString(); }### Answer:
@Test public void testOverNexus() throws Exception { @SuppressWarnings("resource") final TopicLogger logger = new TopicLogger().withExcludeTopics(Topic.of("t")); edge = EdgeNode.builder() .withServerConfig(new XServerConfig().withPort(SocketUtils.getAvailablePort(PORT))) .withPlugins(logger) .build(); remote = RemoteNode.builder().build(); final RemoteNexusHandler handler = mock(RemoteNexusHandler.class); final RemoteNexus nexus = remote.open(new URI("ws: nexus.bind(new BindFrame().withSubscribe("test")).get(); nexus.publish(new PublishBinaryFrame("test", "test".getBytes())); nexus.publish(new PublishTextFrame("test", "test")); SocketUtils.await().until(() -> { verify(handler).onText(notNull(), notNull(), notNull()); verify(handler).onBinary(notNull(), notNull(), notNull()); }); } |
### Question:
KafkaBackplane implements Backplane, RecordHandler<String, KafkaData> { @Override public String toString() { return "KafkaBackplane [config: " + config + ", clusterId: " + clusterId + ", brokerId: " + brokerId + "]"; } KafkaBackplane(@YInject(name="backplaneConfig") KafkaBackplaneConfig config,
@YInject(name="clusterId") String clusterId,
@YInject(name="brokerId") String brokerId); KafkaBackplane(KafkaBackplaneConfig config,
String clusterId,
String brokerId,
ErrorHandler errorHandler); @Override void attach(BackplaneConnector connector); @Override void onReceive(ConsumerRecords<String, KafkaData> records); @Override void onPublish(EdgeNexus nexus, PublishTextFrame pub); @Override void onPublish(EdgeNexus nexus, PublishBinaryFrame pub); @Override void close(); @Override String toString(); }### Answer:
@Test public void testToString() { assertNotNull(backplane.toString()); } |
### Question:
ScramjetMessage { @Override public String toString() { return "ScramjetMessage [id=" + id + ", messageType=" + messageType + ", payload=" + payload + ", publisher=" + publisher + ", sentAt=" + sentAt + "]"; } ScramjetMessage(String id, String messageType, Object payload, String publisher, Date sentAt); String getId(); String getMessageType(); Object getPayload(); String getPublisher(); Date getSentAt(); @Override int hashCode(); @Override boolean equals(Object obj); @Override String toString(); static ScramjetMessage fromJson(Gson gson, String json); String toJson(Gson gson); static GsonBuilder defaultGsonBuilder(); static final String TYPE_ATT; }### Answer:
@Test public void testObjectPayload() { test(new ScramjetMessage(UUID.randomUUID().toString(), "TestMessage", newTestObject(), "junit", new Date())); }
@Test public void testMapPayload() { test(new ScramjetMessage(UUID.randomUUID().toString(), "TestMessage", newTestObject().getAttributes(), "junit", new Date())); }
@Test public void testStringPayload() { test(new ScramjetMessage(UUID.randomUUID().toString(), "TestMessage", "payload", "junit", new Date())); }
@Test public void testDoublePayload() { test(new ScramjetMessage(UUID.randomUUID().toString(), "TestMessage", 12.34, "junit", new Date())); }
@Test public void testBooleanPayload() { test(new ScramjetMessage(UUID.randomUUID().toString(), "TestMessage", true, "junit", new Date())); }
@Test public void testArrayPayload() { test(new ScramjetMessage(UUID.randomUUID().toString(), "TestMessage", Arrays.asList("eenie", "meenie", "minie"), "junit", new Date())); }
@Test public void testNullPayload() { test(new ScramjetMessage(UUID.randomUUID().toString(), "TestMessage", null, "junit", new Date())); }
@Test public void testPushUpdateString() { final ScramjetPushUpdate push = new ScramjetPushUpdate("test/topic", 30, "testPayload"); test(new ScramjetMessage(UUID.randomUUID().toString(), "TestMessage", push, "junit", new Date())); }
@Test public void testPushUpdateMap() { final ScramjetPushUpdate push = new ScramjetPushUpdate("test/topic", 30, newTestObject().getAttributes()); test(new ScramjetMessage(UUID.randomUUID().toString(), "TestMessage", push, "junit", new Date())); } |
### Question:
KafkaBackplaneConfig { @Override public String toString() { return "KafkaBackplaneConfig [kafka: " + kafka + ", topic: " + topic + ", serializer: " + serializer + ", deserializer: " + deserializer + ", pollTimeoutMillis: " + pollTimeoutMillis + ", ttlMillis: " + ttlMillis + "]"; } @Override String toString(); @YInject
public Kafka<String, KafkaData> kafka; @YInject
public String topic; @YInject
public Class<? extends Serializer<KafkaData>> serializer; @YInject
public Class<? extends Deserializer<KafkaData>> deserializer; @YInject
public long pollTimeoutMillis; @YInject
public long ttlMillis; }### Answer:
@Test public void testLoadConfig() throws IOException { final KafkaBackplaneConfig config = new MappingContext() .withParser(new SnakeyamlParser()) .fromStream(KafkaBackplaneConfigTest.class.getClassLoader().getResourceAsStream("kafka-backplane-config.yaml")) .map(KafkaBackplaneConfig.class); assertNotNull(config.toString()); final KafkaCluster<String, KafkaData> kafka = (KafkaCluster<String, KafkaData>) config.kafka; assertNotNull(kafka.getConfig().getCommonProps()); assertNotNull(kafka.getConfig().getProducerProps()); assertNotNull(kafka.getConfig().getConsumerProps()); final Properties consumerProps = new Properties(); consumerProps.setProperty("key.deserializer", StringDeserializer.class.getName()); consumerProps.setProperty("value.deserializer", config.deserializer.getName()); kafka.getConsumer(consumerProps); final Properties producerProps = new Properties(); producerProps.setProperty("key.serializer", StringSerializer.class.getName()); producerProps.setProperty("value.serializer", config.serializer.getName()); kafka.getProducer(producerProps); } |
### Question:
AttributeReader { <T> T read(String key) { return read(key, () -> null); } AttributeReader(Map<String, Object> atts); }### Answer:
@Test public void testReadNoDefault() { assertEquals("bar", reader.read("foo")); assertNull(reader.read("baz")); }
@Test public void testReadDefault() { assertEquals("default", reader.read("baz", () -> "default")); } |
### Question:
AttributeReader { String getTypeName() { return (String) atts.get(ScramjetMessage.TYPE_ATT); } AttributeReader(Map<String, Object> atts); }### Answer:
@Test public void testGetTypeName() { assertEquals("type", reader.getTypeName()); } |
### Question:
AttributeReader { Map<String, Object> getAttributes() { return atts; } AttributeReader(Map<String, Object> atts); }### Answer:
@Test public void testGetAttributes() { assertEquals("bar", reader.getAttributes().get("foo")); } |
### Question:
Launchpad { static File getProfilePath(Map<String, String> env) { final String propertyName = "flywheel.launchpad.profile"; final String envName = "FLYWHEEL_PROFILE"; final String profileProp = System.getProperty(propertyName); final File profilePath; if (profileProp != null) { profilePath = new File(profileProp); } else { final String profileEnv = env.get(envName); if (profileEnv != null) { profilePath = new File(profileEnv); } else { profilePath = new File(DEF_PROFILE); } } return profilePath; } Launchpad(File profilePath); void launch(String[] args); Profile getProfile(); static void main(String... args); }### Answer:
@Test public void testGetProfilePathProperty() { System.setProperty("flywheel.launchpad.profile", "conf/test-good"); final File path = Launchpad.getProfilePath(new HashMap<>()); assertNotNull(path); assertEquals("conf/test-good", path.getPath()); }
@Test public void testGetProfilePathEnvDefault() { final File path = Launchpad.getProfilePath(new HashMap<>()); assertNotNull(path); assertEquals("conf/default", path.getPath()); }
@Test public void testGetProfilePathEnvSupplied() { final Map<String, String> env = new HashMap<>(); env.put("FLYWHEEL_PROFILE", "conf/test-good"); final File path = Launchpad.getProfilePath(env); assertNotNull(path); assertEquals("conf/test-good", path.getPath()); } |
### Question:
Launchpad { public static void main(String... args) { bootstrap(args, System::exit); } Launchpad(File profilePath); void launch(String[] args); Profile getProfile(); static void main(String... args); }### Answer:
@Test public void testMain() { System.setProperty("flywheel.launchpad.profile", "conf/test-good"); Launchpad.main(); } |
### Question:
Launchpad { static void bootstrap(String[] args, IntConsumer exitHandler) { try { new Launchpad(getProfilePath(System.getenv())).launch(args); } catch (LaunchpadException e) { err.format("Error:\n"); e.printStackTrace(err); exitHandler.accept(1); } } Launchpad(File profilePath); void launch(String[] args); Profile getProfile(); static void main(String... args); }### Answer:
@Test public void testBootstrap() { final IntConsumer exitHandler = mock(IntConsumer.class); System.setProperty("flywheel.launchpad.profile", "conf/test-bad"); Launchpad.bootstrap(new String[0], exitHandler); verify(exitHandler).accept(eq(1)); } |
### Question:
HttpStubAuthenticatorConfig { @Override public String toString() { return "HttpStubAuthenticatorConfig [uri: " + uri + ", poolSize: " + poolSize + ", timeoutMillis: " + timeoutMillis + "]"; } HttpStubAuthenticatorConfig withURI(URI uri); HttpStubAuthenticatorConfig withPoolSize(int poolSize); HttpStubAuthenticatorConfig withTimeoutMillis(int timeoutMillis); @Override String toString(); }### Answer:
@Test public void test() throws IOException, URISyntaxException { try (HttpStubAuthenticator auth = new MappingContext() .withParser(new SnakeyamlParser()) .fromStream(HttpStubAuthenticatorConfigTest.class.getClassLoader().getResourceAsStream("http-stub-auth-config.yaml")) .map(HttpStubAuthenticator.class)) { assertEquals(new URI("http: assertEquals(4, auth.getConfig().poolSize); assertEquals(30000, auth.getConfig().timeoutMillis); assertNotNull(auth.toString()); assertNotNull(auth.getConfig().toString()); } } |
### Question:
KafkaReceiver extends Thread implements AutoCloseable { public void await() throws InterruptedException { join(); } KafkaReceiver(Consumer<K, V> consumer, long pollTimeoutMillis, String threadName,
RecordHandler<K, V> handler, ErrorHandler errorHandler); static ErrorHandler genericErrorLogger(Logger logger); @Override void run(); @Override void close(); void await(); }### Answer:
@Test public void testReceive() { final Map<TopicPartition, List<ConsumerRecord<String, String>>> recordsMap = Collections.singletonMap(new TopicPartition("test", 0), Arrays.asList(new ConsumerRecord<>("test", 0, 0, "key", "value"))); final ConsumerRecords<String, String> records = new ConsumerRecords<>(recordsMap); when(consumer.poll(notNull())).then(split(() -> records, () -> new ConsumerRecords<>(Collections.emptyMap()))); receiver = new KafkaReceiver<String, String>(consumer, 1, "TestThread", recordHandler, errorHandler); SocketUtils.await().until(() -> { verify(recordHandler, times(1)).onReceive(eq(records)); verify(errorHandler, never()).onError(any()); }); }
@Test public void testInterrupt() throws InterruptedException { when(consumer.poll(notNull())).then(split(() -> { throw createInterruptException(); })); receiver = new KafkaReceiver<String, String>(consumer, 1, "TestThread", recordHandler, errorHandler); verify(recordHandler, never()).onReceive(any()); verify(errorHandler, never()).onError(any()); receiver.await(); } |
### Question:
KafkaReceiver extends Thread implements AutoCloseable { public static ErrorHandler genericErrorLogger(Logger logger) { return cause -> logger.warn("Error processing Kafka record", cause); } KafkaReceiver(Consumer<K, V> consumer, long pollTimeoutMillis, String threadName,
RecordHandler<K, V> handler, ErrorHandler errorHandler); static ErrorHandler genericErrorLogger(Logger logger); @Override void run(); @Override void close(); void await(); }### Answer:
@Test public void testGenericErrorLogger() { when(consumer.poll(notNull())).then(split(() -> { throw new RuntimeException("boom"); })); final Logger logger = mock(Logger.class); receiver = new KafkaReceiver<String, String>(consumer, 1, "TestThread", recordHandler, KafkaReceiver.genericErrorLogger(logger)); SocketUtils.await().until(() -> { verify(recordHandler, never()).onReceive(any()); verify(logger, atLeastOnce()).warn(anyString(), any(RuntimeException.class)); }); } |
### Question:
ScramjetSerializer implements Serializer<KafkaData> { @Override public byte[] serialize(String topic, KafkaData data) { if (data.isError()) throw new IllegalArgumentException("Cannot serialize an error"); final ScramjetMessage msg = toScramjet(data); final String json = msg.toJson(gson); return s.serialize(topic, json); } @Override void configure(Map<String, ?> configs, boolean isKey); @Override byte[] serialize(String topic, KafkaData data); @Override void close(); }### Answer:
@Test(expected=IllegalArgumentException.class) public void testSerializeError() { final KafkaData d = new KafkaData(new RuntimeException()); serializer.serialize("test", d); } |
### Question:
KafkaBackplane implements Backplane, RecordHandler<String, KafkaData> { @Override public void attach(BackplaneConnector connector) { LOG.debug("Attaching Kafka backplane..."); this.connector = connector; final Consumer<String, KafkaData> consumer = config.kafka.getConsumer(getConsumerProps()); seekToEnd(consumer, config.topic); final String threadName = "KafkaReceiver-" + clusterId + "-" + brokerId + "-" + config.topic; receiver = new KafkaReceiver<>( consumer, config.pollTimeoutMillis, threadName, this, KafkaReceiver.genericErrorLogger(LOG)); producer = config.kafka.getProducer(getProducerProps()); LOG.debug("Backplane attached"); } KafkaBackplane(@YInject(name="backplaneConfig") KafkaBackplaneConfig config,
@YInject(name="clusterId") String clusterId,
@YInject(name="brokerId") String brokerId); KafkaBackplane(KafkaBackplaneConfig config,
String clusterId,
String brokerId,
ErrorHandler errorHandler); @Override void attach(BackplaneConnector connector); @Override void onReceive(ConsumerRecords<String, KafkaData> records); @Override void onPublish(EdgeNexus nexus, PublishTextFrame pub); @Override void onPublish(EdgeNexus nexus, PublishBinaryFrame pub); @Override void close(); @Override String toString(); }### Answer:
@Test public void testAttach() { attach(); }
@Test public void testOnReceiveText() { final BackplaneConnector connector = attach(); final KafkaData d = new KafkaData("id", "source", "topic", null, "hello", System.currentTimeMillis(), System.currentTimeMillis() + 10_000); getProducer().send(new ProducerRecord<>(config.topic, d)); SocketUtils.await().until(() -> { Mockito.verify(connector).publish(Mockito.eq("topic"), Mockito.eq("hello")); }); }
@Test public void testOnReceiveBinary() { final BackplaneConnector connector = attach(); final byte[] bytes = "hello".getBytes(); final KafkaData d = new KafkaData("id", "source", "topic", bytes, null, System.currentTimeMillis(), System.currentTimeMillis() + 10_000); getProducer().send(new ProducerRecord<>(config.topic, d)); SocketUtils.await().until(() -> { Mockito.verify(connector).publish(Mockito.eq("topic"), Mockito.eq(bytes)); }); }
@Test public void testOnReceiveError() { final BackplaneConnector connector = attach(); final KafkaData d = new KafkaData(new RuntimeException("boom")); getProducer().send(new ProducerRecord<>(config.topic, d)); SocketUtils.await().until(() -> { Mockito.verify(connector, Mockito.never()).publish(Mockito.anyString(), Mockito.anyString()); Mockito.verify(connector, Mockito.never()).publish(Mockito.anyString(), Mockito.any(byte[].class)); Mockito.verify(logger, Mockito.atLeastOnce()).warn(Mockito.any(), Mockito.any(RuntimeException.class)); }); } |
### Question:
WebExceptionHandlerOperationsImpl implements
WebExceptionHandlerOperations { public String getHandledExceptionList() { String webXmlPath = pathResolver.getIdentifier( LogicalPath.getInstance(Path.SRC_MAIN_WEBAPP, ""), WEB_MVC_CONFIG); Validate.isTrue(fileManager.exists(webXmlPath), WEB_MVC_CONFIG_NOT_FOUND); MutableFile webXmlMutableFile = null; Document webXml; try { webXmlMutableFile = fileManager.updateFile(webXmlPath); webXml = XmlUtils.getDocumentBuilder().parse( webXmlMutableFile.getInputStream()); } catch (Exception e) { throw new IllegalStateException(e); } Element root = webXml.getDocumentElement(); List<Element> simpleMappingException = null; simpleMappingException = XmlUtils.findElements(RESOLVER_BEAN_MESSAGE + "/property[@name='exceptionMappings']/props/prop", root); Validate.notNull(simpleMappingException, "There aren't Exceptions handled by the application."); StringBuilder exceptionList = new StringBuilder("Handled Exceptions:\n"); for (Element element : simpleMappingException) { exceptionList.append(element.getAttribute("key") + "\n"); } return exceptionList.toString(); } String getHandledExceptionList(); void addNewHandledException(String exceptionName,
String exceptionTitle, String exceptionDescription,
String exceptionLanguage); void removeExceptionHandled(String exceptionName); void languageExceptionHandled(String exceptionName,
String exceptionTitle, String exceptionDescription,
String exceptionLanguage); String getLanguagePropertiesFile(String exceptionLanguage); void setUpGvNIXExceptions(); boolean isExceptionMappingAvailable(); boolean isMessageMappingAvailable(); boolean isProjectAvailable(); static String getFilename(String path); WebProjectUtils getWebProjectUtils(); MessageBundleUtils getMessageBundleUtils(); OperationUtils getOperationUtils(); }### Answer:
@Test public void testGetHandledExceptionList() throws Exception { String result; String expected; expect( pathResolver.getIdentifier( LogicalPath.getInstance(Path.SRC_MAIN_WEBAPP, ""), WEB_XML_PATH)).andReturn(EXC_WEB_XML); expect(fileManager.exists(EXC_WEB_XML)).andReturn(true); expect(fileManager.updateFile(EXC_WEB_XML)) .andReturn(webXmlMutableFile); expect(webXmlMutableFile.getInputStream()).andReturn( getClass().getResourceAsStream(EXC_WEB_XML)); replay(pathResolver, fileManager, webXmlMutableFile); result = webExceptionHandlerOperationsImpl.getHandledExceptionList(); assertTrue("Test 1 \nThere aren't exceptions defined in " + EXC_WEB_XML + " file", result != null); logger.log(Level.INFO, "Test 1 \nExceptions defined in " + EXC_WEB_XML + " :\n" + result); reset(pathResolver, fileManager, webXmlMutableFile); expect( pathResolver.getIdentifier( LogicalPath.getInstance(Path.SRC_MAIN_WEBAPP, ""), WEB_XML_PATH)).andReturn(NO_EXC_WEB_XML); expect(fileManager.exists(NO_EXC_WEB_XML)).andReturn(true); expect(fileManager.updateFile(NO_EXC_WEB_XML)).andReturn( webXmlMutableFile); expect(webXmlMutableFile.getInputStream()).andReturn( getClass().getResourceAsStream(NO_EXC_WEB_XML)); replay(pathResolver, fileManager, webXmlMutableFile); result = webExceptionHandlerOperationsImpl.getHandledExceptionList(); expected = "Handled Exceptions:\n"; assertEquals("Test 2 \nThere are exceptions defined in " + NO_EXC_WEB_XML + " file", expected, result); logger.log(Level.INFO, "Test 2 \nThere aren't exceptions defined in " + NO_EXC_WEB_XML); reset(pathResolver, fileManager, webXmlMutableFile); } |
### Question:
WsdlParserUtils { protected static String getLocalName(String elementName) { Validate.notNull(elementName, "Element name required"); return elementName.replaceFirst(getNamespace(elementName) + NAMESPACE_SEPARATOR, ""); } static String getTargetNamespace(Element root); static String getTargetNamespaceRelatedPackage(Element root); static String makePackageName(String namespace); static boolean isJavaKeyword(String keyword); static String makeNonJavaKeyword(String keyword); static Element findFirstCompatibleAddress(Element root); static String getServiceClassPath(Element root, WsType sense); static String getPortTypeClassPath(Element root, WsType sense); static File getPortTypeJavaFile(Element root, WsType sense); static String findFirstCompatibleServiceElementName(Element root); static Element findFirstCompatiblePort(Element root); static Element checkCompatiblePort(Element root); static Element checkCompatibleAddress(Element root); static String findFirstCompatiblePortClassName(Element root,
WsType sense); static boolean isJavaId(String id); static String xmlNameToJavaClass(String name); static String capitalizeFirstChar(String name); static String xmlNameToJava(String name); static boolean isRpcEncoded(Element root); static Element validateWsdlUrl(String url); static final String SOAP_11_NAMESPACE; static final String NAMESPACE_WITHOUT_SLASH_11; static final String SOAP_12_NAMESPACE; static final String NAMESPACE_WITHOUT_SLASH_12; static final String XML_NAMESPACE_PREFIX; static final String NAMESPACE_SEPARATOR; static final String FILE_SEPARATOR; static final String XPATH_SEPARATOR; static final String PACKAGE_SEPARATOR; static final char javaPkgSeparator; static final Collator englishCollator; static final char keywordPrefix; static final String TARGET_GENERATED_SOURCES_PATH; static final String DEFINITIONS_ELEMENT; static final String BINDING_ELEMENT; static final String PORT_TYPE_ELEMENT; static final String SERVICE_ELEMENT; static final String PORT_ELEMENT; static final String ADDRESS_ELEMENT; static final String TARGET_NAMESPACE_ATTRIBUTE; static final String NAME_ATTRIBUTE; static final String BINDING_ATTRIBUTE; static final String TYPE_ATTRIBUTE; static final String STYLE_ATTRIBUTE; static final String BINDINGS_XPATH; static final String PORT_TYPES_XPATH; static final String ADDRESSES_XPATH; static final String CHILD_BINDINGS_XPATH; }### Answer:
@Test public void testGetLocalName() throws Exception { assertEquals("address", WsdlParserUtils.getLocalName("soap:address")); } |
### Question:
WsdlParserUtils { protected static String getNamespace(String elementName) { Validate.notNull(elementName, "Element name required"); String prefix = ""; int index = elementName.indexOf(NAMESPACE_SEPARATOR); if (index != -1) { prefix = elementName.substring(0, index); } return prefix; } static String getTargetNamespace(Element root); static String getTargetNamespaceRelatedPackage(Element root); static String makePackageName(String namespace); static boolean isJavaKeyword(String keyword); static String makeNonJavaKeyword(String keyword); static Element findFirstCompatibleAddress(Element root); static String getServiceClassPath(Element root, WsType sense); static String getPortTypeClassPath(Element root, WsType sense); static File getPortTypeJavaFile(Element root, WsType sense); static String findFirstCompatibleServiceElementName(Element root); static Element findFirstCompatiblePort(Element root); static Element checkCompatiblePort(Element root); static Element checkCompatibleAddress(Element root); static String findFirstCompatiblePortClassName(Element root,
WsType sense); static boolean isJavaId(String id); static String xmlNameToJavaClass(String name); static String capitalizeFirstChar(String name); static String xmlNameToJava(String name); static boolean isRpcEncoded(Element root); static Element validateWsdlUrl(String url); static final String SOAP_11_NAMESPACE; static final String NAMESPACE_WITHOUT_SLASH_11; static final String SOAP_12_NAMESPACE; static final String NAMESPACE_WITHOUT_SLASH_12; static final String XML_NAMESPACE_PREFIX; static final String NAMESPACE_SEPARATOR; static final String FILE_SEPARATOR; static final String XPATH_SEPARATOR; static final String PACKAGE_SEPARATOR; static final char javaPkgSeparator; static final Collator englishCollator; static final char keywordPrefix; static final String TARGET_GENERATED_SOURCES_PATH; static final String DEFINITIONS_ELEMENT; static final String BINDING_ELEMENT; static final String PORT_TYPE_ELEMENT; static final String SERVICE_ELEMENT; static final String PORT_ELEMENT; static final String ADDRESS_ELEMENT; static final String TARGET_NAMESPACE_ATTRIBUTE; static final String NAME_ATTRIBUTE; static final String BINDING_ATTRIBUTE; static final String TYPE_ATTRIBUTE; static final String STYLE_ATTRIBUTE; static final String BINDINGS_XPATH; static final String PORT_TYPES_XPATH; static final String ADDRESSES_XPATH; static final String CHILD_BINDINGS_XPATH; }### Answer:
@Test public void testGetNamespace() throws Exception { assertEquals("soap", WsdlParserUtils.getNamespace("soap:address")); } |
### Question:
WsdlParserUtils { public static String getTargetNamespaceRelatedPackage(Element root) { Validate.notNull(root, ROOT_ELEMENT_REQUIRED); String namespace = getTargetNamespace(root); String pkg = getTargetNamespaceRelatedPackage(namespace, root) .toLowerCase(); pkg = pkg.replace('_', 'u'); return pkg.concat("."); } static String getTargetNamespace(Element root); static String getTargetNamespaceRelatedPackage(Element root); static String makePackageName(String namespace); static boolean isJavaKeyword(String keyword); static String makeNonJavaKeyword(String keyword); static Element findFirstCompatibleAddress(Element root); static String getServiceClassPath(Element root, WsType sense); static String getPortTypeClassPath(Element root, WsType sense); static File getPortTypeJavaFile(Element root, WsType sense); static String findFirstCompatibleServiceElementName(Element root); static Element findFirstCompatiblePort(Element root); static Element checkCompatiblePort(Element root); static Element checkCompatibleAddress(Element root); static String findFirstCompatiblePortClassName(Element root,
WsType sense); static boolean isJavaId(String id); static String xmlNameToJavaClass(String name); static String capitalizeFirstChar(String name); static String xmlNameToJava(String name); static boolean isRpcEncoded(Element root); static Element validateWsdlUrl(String url); static final String SOAP_11_NAMESPACE; static final String NAMESPACE_WITHOUT_SLASH_11; static final String SOAP_12_NAMESPACE; static final String NAMESPACE_WITHOUT_SLASH_12; static final String XML_NAMESPACE_PREFIX; static final String NAMESPACE_SEPARATOR; static final String FILE_SEPARATOR; static final String XPATH_SEPARATOR; static final String PACKAGE_SEPARATOR; static final char javaPkgSeparator; static final Collator englishCollator; static final char keywordPrefix; static final String TARGET_GENERATED_SOURCES_PATH; static final String DEFINITIONS_ELEMENT; static final String BINDING_ELEMENT; static final String PORT_TYPE_ELEMENT; static final String SERVICE_ELEMENT; static final String PORT_ELEMENT; static final String ADDRESS_ELEMENT; static final String TARGET_NAMESPACE_ATTRIBUTE; static final String NAME_ATTRIBUTE; static final String BINDING_ATTRIBUTE; static final String TYPE_ATTRIBUTE; static final String STYLE_ATTRIBUTE; static final String BINDINGS_XPATH; static final String PORT_TYPES_XPATH; static final String ADDRESSES_XPATH; static final String CHILD_BINDINGS_XPATH; }### Answer:
@Test public void testGetTargetNamespaceRelatedPackage() throws Exception { Document wsdl = XmlUtils.getDocumentBuilder().parse(TEMP_CONVERT_WSDL); Element root = wsdl.getDocumentElement(); assertEquals("com.w3schools.www.webservices.", WsdlParserUtils.getTargetNamespaceRelatedPackage(root)); File file = new File(SRC_TEST_RESOURCES_PATH, TEMP_CONVERT_MODIFIED_LOCAL_WSDL); wsdl = XmlUtils.getDocumentBuilder().parse(file); root = wsdl.getDocumentElement(); assertEquals("org.te3mupuuri.www.kk.idu1ur.", WsdlParserUtils.getTargetNamespaceRelatedPackage(root)); wsdl = XmlUtils.getDocumentBuilder().parse(ELASTIC_MAP_REDUCE_WSDL); root = wsdl.getDocumentElement(); assertEquals("com.amazonaws.elasticmapreduce.doc.u2009u03u31.", WsdlParserUtils.getTargetNamespaceRelatedPackage(root)); } |
### Question:
WsdlParserUtils { public static String getServiceClassPath(Element root, WsType sense) { Validate.notNull(root, ROOT_ELEMENT_REQUIRED); String path = getTargetNamespaceRelatedPackage(root); String name = findFirstCompatibleServiceClassName(root, sense); if (sense.equals(WsType.IMPORT_RPC_ENCODED)) { name = name.concat("Locator"); } return path + capitalizeFirstChar(name); } static String getTargetNamespace(Element root); static String getTargetNamespaceRelatedPackage(Element root); static String makePackageName(String namespace); static boolean isJavaKeyword(String keyword); static String makeNonJavaKeyword(String keyword); static Element findFirstCompatibleAddress(Element root); static String getServiceClassPath(Element root, WsType sense); static String getPortTypeClassPath(Element root, WsType sense); static File getPortTypeJavaFile(Element root, WsType sense); static String findFirstCompatibleServiceElementName(Element root); static Element findFirstCompatiblePort(Element root); static Element checkCompatiblePort(Element root); static Element checkCompatibleAddress(Element root); static String findFirstCompatiblePortClassName(Element root,
WsType sense); static boolean isJavaId(String id); static String xmlNameToJavaClass(String name); static String capitalizeFirstChar(String name); static String xmlNameToJava(String name); static boolean isRpcEncoded(Element root); static Element validateWsdlUrl(String url); static final String SOAP_11_NAMESPACE; static final String NAMESPACE_WITHOUT_SLASH_11; static final String SOAP_12_NAMESPACE; static final String NAMESPACE_WITHOUT_SLASH_12; static final String XML_NAMESPACE_PREFIX; static final String NAMESPACE_SEPARATOR; static final String FILE_SEPARATOR; static final String XPATH_SEPARATOR; static final String PACKAGE_SEPARATOR; static final char javaPkgSeparator; static final Collator englishCollator; static final char keywordPrefix; static final String TARGET_GENERATED_SOURCES_PATH; static final String DEFINITIONS_ELEMENT; static final String BINDING_ELEMENT; static final String PORT_TYPE_ELEMENT; static final String SERVICE_ELEMENT; static final String PORT_ELEMENT; static final String ADDRESS_ELEMENT; static final String TARGET_NAMESPACE_ATTRIBUTE; static final String NAME_ATTRIBUTE; static final String BINDING_ATTRIBUTE; static final String TYPE_ATTRIBUTE; static final String STYLE_ATTRIBUTE; static final String BINDINGS_XPATH; static final String PORT_TYPES_XPATH; static final String ADDRESSES_XPATH; static final String CHILD_BINDINGS_XPATH; }### Answer:
@Test public void testGetServiceClassPath() throws Exception { Document wsdl = XmlUtils.getDocumentBuilder().parse(TEMP_CONVERT_WSDL); Element root = wsdl.getDocumentElement(); assertEquals("com.w3schools.www.webservices.TempConvert", WsdlParserUtils.getServiceClassPath(root, WsType.IMPORT)); File file = new File(SRC_TEST_RESOURCES_PATH, TEMP_CONVERT_MODIFIED_LOCAL_WSDL); wsdl = XmlUtils.getDocumentBuilder().parse(file); root = wsdl.getDocumentElement(); assertEquals( "org.te3mupuuri.www.kk.idu1ur.TEMP_002fC_0023ONe_0040R_002bT$GE_003dR_002aG_0027E_00282_00293_002c4_002f2_0025Rmm12Mm", WsdlParserUtils.getServiceClassPath(root, WsType.IMPORT)); } |
### Question:
WsdlParserUtils { public static String getPortTypeClassPath(Element root, WsType sense) { Validate.notNull(root, ROOT_ELEMENT_REQUIRED); String path = getTargetNamespaceRelatedPackage(root); String portType = findFirstCompatiblePortTypeClassName(root, sense); String port = findFirstCompatiblePortClassName(root, sense); if (WsType.IMPORT_RPC_ENCODED.equals(sense) && portType.equals(port)) { portType = portType.concat("_PortType"); } return path + capitalizeFirstChar(portType); } static String getTargetNamespace(Element root); static String getTargetNamespaceRelatedPackage(Element root); static String makePackageName(String namespace); static boolean isJavaKeyword(String keyword); static String makeNonJavaKeyword(String keyword); static Element findFirstCompatibleAddress(Element root); static String getServiceClassPath(Element root, WsType sense); static String getPortTypeClassPath(Element root, WsType sense); static File getPortTypeJavaFile(Element root, WsType sense); static String findFirstCompatibleServiceElementName(Element root); static Element findFirstCompatiblePort(Element root); static Element checkCompatiblePort(Element root); static Element checkCompatibleAddress(Element root); static String findFirstCompatiblePortClassName(Element root,
WsType sense); static boolean isJavaId(String id); static String xmlNameToJavaClass(String name); static String capitalizeFirstChar(String name); static String xmlNameToJava(String name); static boolean isRpcEncoded(Element root); static Element validateWsdlUrl(String url); static final String SOAP_11_NAMESPACE; static final String NAMESPACE_WITHOUT_SLASH_11; static final String SOAP_12_NAMESPACE; static final String NAMESPACE_WITHOUT_SLASH_12; static final String XML_NAMESPACE_PREFIX; static final String NAMESPACE_SEPARATOR; static final String FILE_SEPARATOR; static final String XPATH_SEPARATOR; static final String PACKAGE_SEPARATOR; static final char javaPkgSeparator; static final Collator englishCollator; static final char keywordPrefix; static final String TARGET_GENERATED_SOURCES_PATH; static final String DEFINITIONS_ELEMENT; static final String BINDING_ELEMENT; static final String PORT_TYPE_ELEMENT; static final String SERVICE_ELEMENT; static final String PORT_ELEMENT; static final String ADDRESS_ELEMENT; static final String TARGET_NAMESPACE_ATTRIBUTE; static final String NAME_ATTRIBUTE; static final String BINDING_ATTRIBUTE; static final String TYPE_ATTRIBUTE; static final String STYLE_ATTRIBUTE; static final String BINDINGS_XPATH; static final String PORT_TYPES_XPATH; static final String ADDRESSES_XPATH; static final String CHILD_BINDINGS_XPATH; }### Answer:
@Test public void testGetPortTypeClassPath() throws Exception { Document wsdl = XmlUtils.getDocumentBuilder().parse(TEMP_CONVERT_WSDL); Element root = wsdl.getDocumentElement(); assertEquals("com.w3schools.www.webservices.TempConvertSoap", WsdlParserUtils.getPortTypeClassPath(root, WsType.IMPORT)); wsdl = XmlUtils.getDocumentBuilder().parse(KK_WEB_SERVICE_ENG_WSDL); root = wsdl.getDocumentElement(); assertEquals("com.konakart.ws.KKWSEngIf", WsdlParserUtils.getPortTypeClassPath(root, WsType.IMPORT)); } |
### Question:
WSConfigServiceImpl implements WSConfigService { public String convertPackageToTargetNamespace(String packageName) { if (!StringUtils.isNotBlank(packageName)) { return ""; } String[] delimitedString = StringUtils.split(packageName, "."); List<String> revertedList = new ArrayList<String>(); String revertedString; for (int i = delimitedString.length - 1; i >= 0; i--) { revertedList.add(delimitedString[i]); } revertedString = collectionToDelimitedString(revertedList, ".", "", ""); revertedString = "http: return revertedString; } boolean install(WsType type); boolean publishClassAsWebService(JavaType className,
AnnotationMetadata annotationMetadata); String convertPackageToTargetNamespace(String packageName); void addToJava2wsPlugin(JavaType serviceClass, String serviceName,
String addressName, String fullyQualifiedTypeName); void installWsdl2javaPlugin(); boolean addImportLocation(String wsdlLocation, WsType type); boolean addWsdlLocation(String wsdlLocation, Document wsdlDocument); void disableWsdlLocation(); boolean importService(JavaType serviceClass, String wsdlLocation,
WsType type); void mvn(String parameters, String message); static String collectionToDelimitedString(List<String> coll,
String delim, String prefix, String suffix); MetadataService getMetadataService(); FileManager getFileManager(); ProjectOperations getProjectOperations(); SecurityService getSecurityService(); AnnotationsService getAnnotationsService(); MavenOperations getMavenOperations(); }### Answer:
@Test public void testConvertPackageToTargetNamespace() throws Exception { String packageName = "org.gvnix.service.roo.addon"; String targetNamespaceExpected = "http: String targetNamespaceResult; targetNamespaceResult = wSConfigServiceImpl .convertPackageToTargetNamespace(packageName); Validate.isTrue( targetNamespaceResult != null && targetNamespaceResult.length() != 0, "The method doesn't work properly."); assertTrue("The namespace is not well generated", targetNamespaceResult.contains(targetNamespaceExpected)); } |
### Question:
Iso20022Util { @Nullable @Contract("!null->!null; null->null;") public static String replaceSwift(@Nullable String text) { if (null == text) { return null; } String result = text; for (String[] swiftReplacement : SWIFT_REPLACEMENTS) { result = result.replace(swiftReplacement[0], swiftReplacement[1]); } result = SWIFT_EXCLUDE_PATTERN.matcher(result).replaceAll("."); result = DOUBLE_QUOTE_PATTERN.matcher(result).replaceAll(Matcher.quoteReplacement("/")); if (result.startsWith("/")) { result = result.substring(1); } return result; } private Iso20022Util(); @Nonnull static XMLGregorianCalendar toXmlGregorianCalendar(@Nonnull LocalDateTime localDateTime); @Nonnull static XMLGregorianCalendar toXmlGregorianCalendar(@Nonnull ZonedDateTime zonedDateTime); @Nonnull static LocalDateTime from(@Nonnull XMLGregorianCalendar calendar); @Nullable static LocalDateTime from(@Nullable DateAndDateTimeChoice choice); @Nullable @Contract("!null->!null; null->null;") static String replaceSwift(@Nullable String text); }### Answer:
@Test public void swiftTest() { String withoutReplacement = "a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y, z, A, B, C, D, E, F, G, H, I, " + "J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9.,:'+-/()?"; String replaceSwift = Iso20022Util.replaceSwift(withoutReplacement); Assert.assertEquals(withoutReplacement, replaceSwift); String withReplacement = "asdfA SDF++* \"13 2456?=)(_:;; M@|#@#|@||@#¼¼½¬|||]¢}"; String expectedAfterReplacement = "asdfA SDF++. .13 2456?.)(.:.. M....................."; replaceSwift = Iso20022Util.replaceSwift(withReplacement); Assert.assertEquals(expectedAfterReplacement, replaceSwift); String withReplacementCH = "!;>÷=àäöü&"; String expectedAfterReplacementCH = ".....aaeoeue+"; replaceSwift = Iso20022Util.replaceSwift(withReplacementCH); Assert.assertEquals(expectedAfterReplacementCH, replaceSwift); String withReplacementCH2 = "51/1/Chindä & Co. Luzärn"; String expectedAfterReplacementCH2 = "51/1/Chindae + Co. Luzaern"; replaceSwift = Iso20022Util.replaceSwift(withReplacementCH2); Assert.assertEquals(expectedAfterReplacementCH2, replaceSwift); String withReplacementDoubleSlash = "/Nicht mit / beginnen und an keiner Stelle String expectedAfterReplacementDoubleSlash = "Nicht mit / beginnen und an keiner Stelle / enthalten."; replaceSwift = Iso20022Util.replaceSwift(withReplacementDoubleSlash); Assert.assertEquals(expectedAfterReplacementDoubleSlash, replaceSwift); } |
### Question:
CamtUtil { public static boolean isMatchingXsdSchema(byte[] xmlAsBytes, @Nonnull String pathToXsd) { try (ByteArrayInputStream xmlAsStream = new ByteArrayInputStream(xmlAsBytes); InputStream xsdAsStream = Thread.currentThread().getContextClassLoader().getResourceAsStream(pathToXsd)) { SchemaFactory factory = SchemaFactory.newInstance(XMLConstants.W3C_XML_SCHEMA_NS_URI); Schema schema = factory.newSchema(new StreamSource(xsdAsStream)); Validator validator = schema.newValidator(); validator.validate(new StreamSource(xmlAsStream)); return true; } catch (IOException e) { throw new Iso20022RuntimeException("IO Exception while validating xml file with xsd schema", e); } catch (SAXException ignore) { return false; } } private CamtUtil(); @Nonnull static CamtTypeVersion detectCamtTypeVersion(@Nonnull byte[] xmlAsBytes); static boolean isMatchingXsdSchema(byte[] xmlAsBytes, @Nonnull String pathToXsd); }### Answer:
@Test public void validateXmlWithXsdSuccessTest() { assertTrue(CamtUtil.isMatchingXsdSchema(readXml(VALID_CAMT53_XML), CAMT053V00104.getXsdPath())); assertTrue(CamtUtil.isMatchingXsdSchema(readXml(VALID_CAMT54_XML), CAMT054V00104.getXsdPath())); }
@Test public void validateXmlWithXsdFailureTest() { byte[] bytes = readXml(INVALID_XML); assertFalse(CamtUtil.isMatchingXsdSchema(bytes, CAMT054V00104.getXsdPath())); assertFalse(CamtUtil.isMatchingXsdSchema(readXml(VALID_CAMT53_XML), CAMT054V00104.getXsdPath())); assertFalse(CamtUtil.isMatchingXsdSchema(readXml(VALID_CAMT54_XML), CAMT053V00104.getXsdPath())); } |
### Question:
CamtUtil { @Nonnull public static CamtTypeVersion detectCamtTypeVersion(@Nonnull byte[] xmlAsBytes) throws Iso20022RuntimeException { return Arrays.stream(CamtTypeVersion.values()) .filter(type -> isMatchingXsdSchema(xmlAsBytes, type.getXsdPath())) .findAny() .orElseThrow(() -> new Iso20022RuntimeException("Cannot process input. XSD validation failed.")); } private CamtUtil(); @Nonnull static CamtTypeVersion detectCamtTypeVersion(@Nonnull byte[] xmlAsBytes); static boolean isMatchingXsdSchema(byte[] xmlAsBytes, @Nonnull String pathToXsd); }### Answer:
@Test public void detectDetectCamtTypeVersionTest() { assertEquals(CAMT053V00104, CamtUtil.detectCamtTypeVersion(readXml(VALID_CAMT53_XML))); assertEquals(CAMT054V00104, CamtUtil.detectCamtTypeVersion(readXml(VALID_CAMT54_XML))); } |
### Question:
FormatUtil { static int numberOfDigits(long l) { if (l == 0) { return 1; } return ((int) Math.ceil(Math.log10(l + 0.5))); } private FormatUtil(); static void padRight(StringBuilder buf, char c, int count); }### Answer:
@Test public void testNumberOfDigits() { assertThat(FormatUtil.numberOfDigits(0)).isEqualTo(1); assertThat(FormatUtil.numberOfDigits(1)).isEqualTo(1); assertThat(FormatUtil.numberOfDigits(5)).isEqualTo(1); assertThat(FormatUtil.numberOfDigits(10)).isEqualTo(2); assertThat(FormatUtil.numberOfDigits(99)).isEqualTo(2); assertThat(FormatUtil.numberOfDigits(100)).isEqualTo(3); assertThat(FormatUtil.numberOfDigits(1000)).isEqualTo(4); } |
### Question:
SmallFilesReportCommand extends AbstractReportCommand { @Override public void run() { final FsImageData fsImageData = loadFsImage(); if (null != fsImageData) { for (String dir : mainCommand.dirs) { log.debug("Visiting {} ...", dir); long start = System.currentTimeMillis(); final Report report = computeReport(fsImageData, dir); log.info("Visiting directory {} finished [{}ms].", dir, System.currentTimeMillis() - start); handleReport(report); } } } @Override void run(); }### Answer:
@Test public void testRunWithUserNameFilter() { SmallFilesReportCommand command = new SmallFilesReportCommand(); command.mainCommand = new HdfsFSImageTool.MainCommand(); final ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream(); try (PrintStream printStream = new PrintStream(byteArrayOutputStream)) { command.mainCommand.out = printStream; command.mainCommand.err = command.mainCommand.out; command.mainCommand.fsImageFile = new File("src/test/resources/fsi_small.img"); command.mainCommand.userNameFilter = "mm"; command.run(); assertThat(byteArrayOutputStream.toString()) .isEqualTo("\n" + "Small files report (< 2 MiB)\n" + "\n" + "Overall small files : 3\n" + "User (filtered) small files : 2\n" + "\n" + "#Small files | Path (top 10) \n" + "------------------------------\n" + " 3 | /\n" + " 2 | /test3\n" + " 1 | /test3/foo\n" + "\n" + "Username | #Small files | %\n" + "------------------------------------\n" + "mm | 2 | 66.7%\n" + "\n" + "Username | Small files hotspots (top 10 count/path)\n" + "---------------------------------------------------\n" + "mm | 2 | /\n" + " | 1 | /test3\n" + "---------------------------------------------------\n" ); } }
@Test public void testRun() { SmallFilesReportCommand command = new SmallFilesReportCommand(); command.mainCommand = new HdfsFSImageTool.MainCommand(); final ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream(); try (PrintStream printStream = new PrintStream(byteArrayOutputStream)) { command.mainCommand.out = printStream; command.mainCommand.err = command.mainCommand.out; command.mainCommand.fsImageFile = new File("src/test/resources/fsi_small.img"); command.run(); assertThat(byteArrayOutputStream.toString()) .isEqualTo("\n" + "Small files report (< 2 MiB)\n" + "\n" + "Overall small files : 3\n" + "\n" + "#Small files | Path (top 10) \n" + "------------------------------\n" + " 3 | /\n" + " 2 | /test3\n" + " 1 | /test3/foo\n" + "\n" + "Username | #Small files | %\n" + "------------------------------------\n" + "mm | 2 | 66.7%\n" + "root | 1 | 33.3%\n" + "\n" + "Username | Small files hotspots (top 10 count/path)\n" + "---------------------------------------------------\n" + "mm | 2 | /\n" + " | 1 | /test3\n" + "---------------------------------------------------\n" + "root | 1 | /\n" + " | 1 | /test3\n" + " | 1 | /test3/foo\n" + "---------------------------------------------------\n" ); } } |
### Question:
SizeBucket { public long[] computeBucketUpperBorders() { return getBucketModel().computeBucketUpperBorders(findMaxNumBucket()); } SizeBucket(); SizeBucket(BucketModel bucketModel); void add(long size); long[] computeBucketUpperBorders(); int findMaxNumBucket(); long getBucketCounter(int bucket); long[] get(); int size(); BucketModel getBucketModel(); @Override String toString(); }### Answer:
@Test public void testComputeBucketUpperBorders() { SizeBucket sizeBucket = new SizeBucket(); assertThat(sizeBucket.computeBucketUpperBorders()).isEqualTo(new long[]{0 }); sizeBucket.add(1024L); assertThat(sizeBucket.computeBucketUpperBorders()).isEqualTo(new long[]{0, 1024L * 1024L }); } |
### Question:
IECBinary { public static long parse(String formattedValue) { final Matcher matcher = PATTERN_VALUE_WITH_STORAGE_UNIT.matcher(formattedValue); if (!matcher.matches()) { throw new IllegalArgumentException("Expected pattern " + PATTERN_VALUE_WITH_STORAGE_UNIT.pattern() + " but got value <" + formattedValue + ">"); } long number = Long.parseLong(matcher.group(1)); String unit = matcher.group(2); if (null != unit) { for (int i = 0; i < UNITS.length; i++) { if (unit.equalsIgnoreCase(UNITS[i])) { number *= Math.pow(1024, i); break; } } } return number; } private IECBinary(); static String format(long numericalValue); static long parse(String formattedValue); }### Answer:
@Test public void testParse() { for (int i = 0; i < formattedValues.length; i++) { assertThat(IECBinary.parse(formattedValues[i])).isEqualTo(rawValues[i]); } assertThat(IECBinary.parse("0")).isEqualTo(0); assertThat(IECBinary.parse("0B")).isEqualTo(0); assertThat(IECBinary.parse("1 KiB")).isEqualTo(1024); for (String value : new String[]{"", " ", "KiB"}) { assertThatExceptionOfType(IllegalArgumentException.class) .isThrownBy(() -> IECBinary.parse(value)); } } |
### Question:
IECBinary { public static String format(long numericalValue) { if (numericalValue < 1024) { return numericalValue + " B"; } int exp = (int) (Math.log(numericalValue) / Math.log(1024)); String pre = "KMGTPE".charAt(exp - 1) + "i"; return String.format("%.0f %sB", numericalValue / Math.pow(1024, exp), pre); } private IECBinary(); static String format(long numericalValue); static long parse(String formattedValue); }### Answer:
@Test public void testFormat() { for (int i = 0; i < formattedValues.length; i++) { assertThat(IECBinary.format(rawValues[i])).isEqualTo(formattedValues[i]); } assertThat(IECBinary.format(1024 + 512 - 1)).isEqualTo("1 KiB"); assertThat(IECBinary.format(1024 + 512)).isEqualTo("2 KiB"); } |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.