@Test
public void testRegenerateIdCerts() throws GeneralSecurityException, IOException {
// using lconsumer simply to avoid hiding consumer. This should
// get renamed once we refactor this test suite.
IdentityCertServiceAdapter mockedIdSvc = Mockito.mock(IdentityCertServiceAdapter.class);
EventSink sink = Mockito.mock(EventSinkImpl.class);
Consumer consumer = createConsumer();
consumer.setIdCert(createIdCert());
IdentityCertificate ic = consumer.getIdCert();
assertNotNull(ic);
when(mockedConsumerCurator.verifyAndLookupConsumer(consumer.getUuid())).thenReturn(consumer);
when(mockedIdSvc.regenerateIdentityCert(consumer)).thenReturn(createIdCert());
ConsumerResource cr =
new ConsumerResource(
mockedConsumerCurator,
null,
null,
null,
null,
mockedIdSvc,
null,
null,
sink,
eventFactory,
null,
null,
null,
null,
null,
mockedOwnerCurator,
null,
null,
null,
null,
null,
null,
new CandlepinCommonTestConfig(),
null,
null,
null,
consumerBindUtil,
productCurator,
null);
Consumer fooc = cr.regenerateIdentityCertificates(consumer.getUuid());
assertNotNull(fooc);
IdentityCertificate ic1 = fooc.getIdCert();
assertNotNull(ic1);
assertFalse(ic.equals(ic1));
}
/**
* https://github.com/ReactiveX/RxJava/issues/198
*
* <p>Rx Design Guidelines 5.2
*
* <p>"when calling the Subscribe method that only has an onNext argument, the OnError behavior
* will be to rethrow the exception on the thread that the message comes out from the Observable.
* The OnCompleted behavior in this case is to do nothing."
*
* @throws InterruptedException
*/
@Test
@Ignore("Subscribers can't throw")
public void testErrorThrownWithoutErrorHandlerAsynchronous() throws InterruptedException {
final CountDownLatch latch = new CountDownLatch(1);
final AtomicReference<Throwable> exception = new AtomicReference<>();
Observable.create(
observer -> {
new Thread(
() -> {
try {
observer.onError(new Error("failure"));
} catch (Throwable e) {
// without an onError handler it has to just throw on whatever thread
// invokes it
exception.set(e);
}
latch.countDown();
})
.start();
})
.subscribe();
// wait for exception
latch.await(3000, TimeUnit.MILLISECONDS);
assertNotNull(exception.get());
assertEquals("failure", exception.get().getMessage());
}
/**
* The error from the user provided Observable is handled by the subscribe try/catch because this
* is synchronous
*
* <p>Result: Passes
*/
@Test
public void testCustomObservableWithErrorInObservableSynchronous() {
final AtomicInteger count = new AtomicInteger();
final AtomicReference<Throwable> error = new AtomicReference<>();
// FIXME custom built???
Observable.just("1", "2")
.concatWith(Observable.error(() -> new NumberFormatException()))
.subscribe(
new Observer<String>() {
@Override
public void onComplete() {
System.out.println("completed");
}
@Override
public void onError(Throwable e) {
error.set(e);
System.out.println("error");
e.printStackTrace();
}
@Override
public void onNext(String v) {
System.out.println(v);
count.incrementAndGet();
}
});
assertEquals(2, count.get());
assertNotNull(error.get());
if (!(error.get() instanceof NumberFormatException)) {
fail("It should be a NumberFormatException");
}
}
@Test
public void testAddWorkspace() {
int startingVertexCount = graph.getAllVertices().size();
int startingEdgeCount = graph.getAllEdges().size();
String workspaceId = "testWorkspaceId";
idGenerator.push(workspaceId);
idGenerator.push(workspaceId + "_to_" + user1.getUserId());
Workspace workspace = workspaceRepository.add("workspace1", user1);
assertTrue(
authorizationRepository
.getGraphAuthorizations()
.contains(WorkspaceRepository.WORKSPACE_ID_PREFIX + workspaceId));
assertEquals(
startingVertexCount + 1, graph.getAllVertices().size()); // +1 = the workspace vertex
assertEquals(
startingEdgeCount + 1,
graph.getAllEdges().size()); // +1 = the edge between workspace and user1
assertNull(
"Should not have access", graph.getVertex(workspace.getId(), new InMemoryAuthorizations()));
InMemoryAuthorizations authorizations =
new InMemoryAuthorizations(WorkspaceRepository.VISIBILITY_STRING, workspace.getId());
assertNotNull("Should have access", graph.getVertex(workspace.getId(), authorizations));
Workspace foundWorkspace = workspaceRepository.findById(workspace.getId(), user1);
assertEquals(workspace.getId(), foundWorkspace.getId());
}
@Test
public void testCompositeErrorDelayed2() {
final Observable<String> o1 =
Observable.create(
new TestErrorObservable(
"four", null,
"six")); // we expect to lose "six" from the source (and it should never be sent by
// the source since onError was called
final Observable<String> o2 = Observable.create(new TestErrorObservable("one", "two", null));
Observable<String> m = Observable.mergeDelayError(o1, o2);
CaptureObserver w = new CaptureObserver();
m.subscribe(w);
assertNotNull(w.e);
assertEquals(1, w.e.getSuppressed().length);
// if (w.e instanceof CompositeException) {
// assertEquals(2, ((CompositeException) w.e).getExceptions().size());
// w.e.printStackTrace();
// } else {
// fail("Expecting CompositeException");
// }
}
@Test
public void testTakeWithErrorInObserver() {
final AtomicInteger count = new AtomicInteger();
final AtomicReference<Throwable> error = new AtomicReference<>();
Observable.just("1", "2", "three", "4")
.take(3)
.safeSubscribe(
new Observer<String>() {
@Override
public void onComplete() {
System.out.println("completed");
}
@Override
public void onError(Throwable e) {
error.set(e);
System.out.println("error");
e.printStackTrace();
}
@Override
public void onNext(String v) {
int num = Integer.parseInt(v);
System.out.println(num);
// doSomething(num);
count.incrementAndGet();
}
});
assertEquals(2, count.get());
assertNotNull(error.get());
if (!(error.get() instanceof NumberFormatException)) {
fail("It should be a NumberFormatException");
}
}
@Test
public void assertListFromServerIsRetrievedOnce() throws Exception {
when(server.execute(isA(MaskedArgumentListBuilder.class)))
.thenReturn(
new StringReader(
"--------- -------------- -------- ----------------------------------------------------------------------------------------------------------\n"
+ "\n"
+ "name1 SND\\redsolo_cp COMPUTER\n"));
Workspaces workspaces = new Workspaces(server);
Workspace workspace = workspaces.getWorkspace("name1");
assertNotNull("Workspace was null", workspace);
workspace = workspaces.getWorkspace("name1");
assertNotNull("Workspace was null", workspace);
verify(server, times(1)).execute(isA(MaskedArgumentListBuilder.class));
}
@Test
public void shouldMaintainPreviousDefaultAnswer() {
// given
mock = mock(IMethods.class, RETURNS_MOCKS);
// when
reset(mock);
// then
assertNotNull(mock.iMethodsReturningMethod());
}
public void test_create_with_annotated_dao() {
DaoInvokerFactory factory = DaoInvokerFactory.getInstance();
FullAnnotatedDao daoMock = mock(FullAnnotatedDao.class);
DaoInvoker daoInvoker = factory.create(daoMock, objectStore);
assertNotNull(daoInvoker);
Object entity = new Object();
daoInvoker.insert(entity);
verify(daoMock).insertIt(same(entity));
assertNotNull(objectStore.get(DaoInvokerFactory.REPOSITORY_KEY));
}
@Test
public void assertGettingNewWorkspaceIsNotRetrievingServerList() throws Exception {
when(server.execute(isA(MaskedArgumentListBuilder.class))).thenReturn(new StringReader(""));
Workspaces workspaces = new Workspaces(server);
workspaces.newWorkspace("name1");
assertNotNull("The get new workspace returned null", workspaces.getWorkspace("name1"));
verify(server, times(1)).execute(isA(MaskedArgumentListBuilder.class));
}
@Test
public void assertNewWorkspaceIsAddedToMap() throws Exception {
when(server.execute(isA(MaskedArgumentListBuilder.class))).thenReturn(new StringReader(""));
Workspaces workspaces = new Workspaces(server);
Workspace workspace = workspaces.newWorkspace("name1");
assertNotNull("The new workspace was null", workspace);
assertTrue("The workspace was reported as non existant", workspaces.exists(workspace));
}
public void test_getInstance() {
DaoInvokerFactory factory = DaoInvokerFactory.getInstance();
assertNotNull(factory);
DaoInvokerFactory factory2 = DaoInvokerFactory.getInstance();
assertSame(factory, factory2);
}
@Test
public void renderAvatarShouldNotReturnNotModifiedAvatarInResponse()
throws IOException, NotFoundException {
JCUser user = getUser();
user.setAvatar(validAvatar);
user.setAvatarLastModificationTime(new DateTime(0));
when(userService.get(anyLong())).thenReturn(user);
MockHttpServletResponse response = new MockHttpServletResponse();
MockHttpServletRequest request = new MockHttpServletRequest();
request.addHeader(avatarController.IF_MODIFIED_SINCE_HEADER, new Date(1000));
avatarController.renderAvatar(request, response, 0L);
assertEquals(response.getStatus(), HttpServletResponse.SC_NOT_MODIFIED);
assertNotSame(response.getContentAsByteArray(), validAvatar);
assertEquals(response.getHeader("Pragma"), "public");
List<String> cacheControlHeaders = response.getHeaders("Cache-Control");
assertTrue(cacheControlHeaders.contains("public"));
assertTrue(cacheControlHeaders.contains("must-revalidate"));
assertTrue(cacheControlHeaders.contains("max-age=0"));
assertNotNull(response.getHeader("Expires")); // System.currentTimeMillis() is used
assertNotNull(response.getHeader("Last-Modified")); // depends on current timezone
}
@Test
public void testGetUserSettings() throws Exception {
final List<IUserSetting> settings = userSettingService.getUserSettings();
assertNotNull(settings);
assertEquals(3, settings.size());
for (IUserSetting setting : settings) {
if (COMMON_SETTING_NAME.equals(setting.getSettingName())) {
assertEquals(COMMON_USER_SETTING_VALUE, setting.getSettingValue());
} else if (USER_SETTING_NAME_3.equals(setting.getSettingName())) {
assertEquals(USER_SETTING_VALUE_3, setting.getSettingValue());
} else if (GLOBAL_SETTING_NAME_3.equals(setting.getSettingName())) {
assertEquals(GLOBAL_SETTING_VALUE_3, setting.getSettingValue());
}
}
}
@Test
public void testGetRankedCertifications() {
List<CertificationType> certifications = new ArrayList<CertificationType>();
Certification cert1 = CredentialFactory.getInstance().createCertification();
Certification cert2 = CredentialFactory.getInstance().createCertification();
Certification cert3 = CredentialFactory.getInstance().createCertification();
certifications.add(cert1.getCertificationType());
certifications.add(cert2.getCertificationType());
certifications.add(cert3.getCertificationType());
when(mockDataService.getAllRanked(CertificationType.class)).thenReturn(certifications);
List<CertificationType> rankedCertifications = action.getRankedCertifications();
assertNotNull(rankedCertifications);
assertEquals(3, rankedCertifications.size());
assertTrue(rankedCertifications.contains(cert1.getCertificationType()));
assertTrue(rankedCertifications.contains(cert2.getCertificationType()));
assertTrue(rankedCertifications.contains(cert3.getCertificationType()));
}
public void test_create_with_mapping_dao_interface() {
DaoInvokerFactory factory = DaoInvokerFactory.getInstance();
@SuppressWarnings("unchecked")
MappingDao<Object> daoMock = mock(MappingDao.class);
DaoInvoker daoInvoker = factory.create(daoMock, objectStore);
assertNotNull(daoInvoker);
Object entity = new Object();
daoInvoker.insert("myInsert", entity);
verify(daoMock).insert(eq("myInsert"), same(entity));
}
@Test
public void bindByPool() throws EntitlementRefusedException {
String poolid = "pool10";
Pool pool = mock(Pool.class);
Entitlement ent = mock(Entitlement.class);
List<Entitlement> eList = new ArrayList<Entitlement>();
eList.add(ent);
when(pm.find(eq(poolid))).thenReturn(pool);
Map<String, Integer> pQs = new HashMap<String, Integer>();
pQs.put(poolid, 1);
when(pm.entitleByPools(eq(consumer), eq(pQs))).thenReturn(eList);
List<Entitlement> ents = entitler.bindByPoolQuantity(consumer, poolid, 1);
assertNotNull(ents);
assertEquals(ent, ents.get(0));
}
@Test
public void testGetGlobalUserSettings() throws Exception {
final List<IUserSetting> globalUserSettings = userSettingService.getGlobalUserSettings();
assertNotNull(globalUserSettings);
assertEquals(2, globalUserSettings.size());
label:
for (IUserSetting setting : globalUserSettings) {
for (String key : globalSettings.keySet()) {
if (key.startsWith(UserSettingService.SETTING_PREFIX)
&& key.substring(UserSettingService.SETTING_PREFIX.length())
.equals(setting.getSettingName())) {
assertEquals(globalSettings.get(key), setting.getSettingValue());
continue label;
}
}
fail("wrong setting");
}
}
/**
* The error from the user provided Observer is not handled by the subscribe method try/catch.
*
* <p>It is handled by the AtomicObserver that wraps the provided Observer.
*
* <p>Result: Passes (if AtomicObserver functionality exists)
*/
@Test
public void testCustomObservableWithErrorInObserverAsynchronous() throws InterruptedException {
final CountDownLatch latch = new CountDownLatch(1);
final AtomicInteger count = new AtomicInteger();
final AtomicReference<Throwable> error = new AtomicReference<>();
// FIXME custom built???
Observable.just("1", "2", "three", "4")
.subscribeOn(Schedulers.newThread())
.safeSubscribe(
new Observer<String>() {
@Override
public void onComplete() {
System.out.println("completed");
latch.countDown();
}
@Override
public void onError(Throwable e) {
error.set(e);
System.out.println("error");
e.printStackTrace();
latch.countDown();
}
@Override
public void onNext(String v) {
int num = Integer.parseInt(v);
System.out.println(num);
// doSomething(num);
count.incrementAndGet();
}
});
// wait for async sequence to complete
latch.await();
assertEquals(2, count.get());
assertNotNull(error.get());
if (!(error.get() instanceof NumberFormatException)) {
fail("It should be a NumberFormatException");
}
}
@Test
public void testGetUserSettingsByName() throws Exception {
final List<IUserSetting> settings = userSettingService.getUserSettings("test");
IAuthorizationPolicy policy = mock(IAuthorizationPolicy.class);
when(policy.isAllowed(anyString())).thenReturn(true);
PentahoSystem.registerObject(policy);
assertNotNull(settings);
assertEquals(2, settings.size());
for (IUserSetting setting : settings) {
if (COMMON_SETTING_NAME.equals(setting.getSettingName())) {
assertEquals(COMMON_USER_SETTING_VALUE, setting.getSettingValue());
} else if (USER_SETTING_NAME_3.equals(setting.getSettingName())) {
assertEquals(USER_SETTING_VALUE_3, setting.getSettingValue());
} else if (GLOBAL_SETTING_NAME_3.equals(setting.getSettingName())) {
assertEquals(GLOBAL_SETTING_VALUE_3, setting.getSettingValue());
}
}
}
@Test
public void overwritesToCacheFileIfCacheFileHasBadContents()
throws IOException, TmcCoreException {
new FileWriter(cache).write(" asdfjljlkasdf ");
ExerciseDownloader downloader = Mockito.mock(ExerciseDownloader.class);
Mockito.when(downloader.createCourseFolder(anyString(), anyString())).thenReturn("");
Mockito.when(downloader.handleSingleExercise(any(Exercise.class), anyString()))
.thenReturn(true);
Course course = new Course();
course.setName("test-course");
course.setExercises(
new ExerciseBuilder()
.withExercise("kissa", 2, "eujwuc")
.withExercise("asdf", 793, "alnwnec")
.withExercise("ankka", 88, "abcdefg")
.build());
parser = Mockito.mock(TmcJsonParser.class);
Mockito.when(parser.getCourse(anyInt())).thenReturn(Optional.of(course));
DownloadExercises dl = new DownloadExercises(downloader, "", "8", cache, settings, parser);
dl.call();
String json = FileUtils.readFileToString(cache);
Gson gson = new Gson();
Map<String, Map<String, String>> checksums;
Type typeOfHashMap = new TypeToken<Map<String, Map<String, String>>>() {}.getType();
checksums = gson.fromJson(json, typeOfHashMap);
assertNotNull(checksums);
assertTrue(checksums.containsKey("test-course"));
assertTrue(checksums.get("test-course").containsKey("kissa"));
assertTrue(checksums.get("test-course").containsKey("asdf"));
assertTrue(checksums.get("test-course").containsKey("ankka"));
assertEquals("eujwuc", checksums.get("test-course").get("kissa"));
assertEquals("alnwnec", checksums.get("test-course").get("asdf"));
assertEquals("abcdefg", checksums.get("test-course").get("ankka"));
}
@Test
public void keepsOldChecksumsInTheCache() throws IOException, TmcCoreException {
try (FileWriter writer = new FileWriter(cache)) {
writer.write(
"{\"test-course\":{\"kissa\":\"qwerty\",\"asdf2\":\"aijw9\"},\"test-course2\":{\"ankka\":\"22222\"}}");
}
ExerciseDownloader mock = Mockito.mock(ExerciseDownloader.class);
Mockito.when(mock.createCourseFolder(anyString(), anyString())).thenReturn("");
Mockito.when(mock.handleSingleExercise(any(Exercise.class), anyString())).thenReturn(true);
Course course = new Course();
course.setName("test-course");
course.setExercises(
new ExerciseBuilder()
.withExercise("kissa", 2, "eujwuc")
.withExercise("asdf", 793, "alnwnec")
.withExercise("ankka", 88, "abcdefg")
.build());
parser = Mockito.mock(TmcJsonParser.class);
Mockito.when(parser.getCourse(anyInt())).thenReturn(Optional.of(course));
DownloadExercises dl = new DownloadExercises(mock, "", "8", cache, settings, parser);
dl.call();
String json = FileUtils.readFileToString(cache);
Type typeOfHashMap = new TypeToken<Map<String, Map<String, String>>>() {}.getType();
Map<String, Map<String, String>> checksums = new Gson().fromJson(json, typeOfHashMap);
assertNotNull(checksums);
assertTrue(checksums.containsKey("test-course"));
assertTrue(checksums.containsKey("test-course2"));
assertTrue(checksums.get("test-course").containsKey("kissa"));
assertTrue(checksums.get("test-course").containsKey("asdf"));
assertTrue(checksums.get("test-course").containsKey("ankka"));
assertEquals("eujwuc", checksums.get("test-course").get("kissa"));
assertEquals("alnwnec", checksums.get("test-course").get("asdf"));
assertEquals("aijw9", checksums.get("test-course").get("asdf2"));
assertEquals("22222", checksums.get("test-course2").get("ankka"));
}
@Test
public void canInstantiateAConcommitingCoursesFilter() {
ConcomittingCoursesFilter filter = new ConcomittingCoursesFilter();
assertNotNull(filter);
}
@Test
public void 정상적으로_리스트를_받아오는지_테스트() {
assertNotNull(appRankingDAO.selectAppRanking());
}