@Test
public void removeConnection() throws Exception {
ConnectionFactoryRegistry connectionFactoryLocator = new ConnectionFactoryRegistry();
ConnectionFactory<TestApi2> connectionFactory =
new StubOAuth2ConnectionFactory("clientId", "clientSecret", THROW_EXCEPTION);
connectionFactoryLocator.addConnectionFactory(connectionFactory);
StubConnectionRepository connectionRepository = new StubConnectionRepository();
connectionRepository.addConnection(
connectionFactory.createConnection(
new ConnectionData(
"oauth2Provider", "provider1User1", null, null, null, null, null, null, null)));
connectionRepository.addConnection(
connectionFactory.createConnection(
new ConnectionData(
"oauth2Provider", "provider1User2", null, null, null, null, null, null, null)));
assertEquals(2, connectionRepository.findConnections("oauth2Provider").size());
ConnectController connectController =
new ConnectController(connectionFactoryLocator, connectionRepository);
List<DisconnectInterceptor<?>> interceptors = getDisconnectInterceptor();
connectController.setDisconnectInterceptors(interceptors);
MockMvc mockMvc = standaloneSetup(connectController).build();
mockMvc
.perform(delete("/connect/oauth2Provider/provider1User1"))
.andExpect(redirectedUrl("/connect/oauth2Provider"));
assertEquals(1, connectionRepository.findConnections("oauth2Provider").size());
assertFalse(((TestConnectInterceptor<?>) (interceptors.get(0))).preDisconnectInvoked);
assertFalse(((TestConnectInterceptor<?>) (interceptors.get(0))).postDisconnectInvoked);
assertNull(((TestConnectInterceptor<?>) (interceptors.get(0))).connectionFactory);
assertTrue(((TestConnectInterceptor<?>) (interceptors.get(1))).preDisconnectInvoked);
assertTrue(((TestConnectInterceptor<?>) (interceptors.get(1))).postDisconnectInvoked);
assertSame(
connectionFactory, ((TestConnectInterceptor<?>) (interceptors.get(1))).connectionFactory);
}
@Test
public void getsFedOptionDescriptorsForRecognizedOptions() {
assertEquals(1, captured.size());
Map.Entry<String, ? extends OptionDescriptor> only = captured.entrySet().iterator().next();
assertEquals("b", only.getKey());
OptionDescriptor descriptor = only.getValue();
assertThat(descriptor.options(), hasSameContentsAs(asList("b")));
assertEquals("boo", descriptor.description());
assertFalse(descriptor.acceptsArguments());
assertFalse(descriptor.requiresArgument());
assertEquals("", descriptor.argumentDescription());
assertEquals("", descriptor.argumentTypeIndicator());
assertEquals(Collections.<Object>emptyList(), descriptor.defaultValues());
}
@Test
public void supportsPosixlyCorrectBehavior() {
OptionParser parser = new OptionParser("i:j::k");
String[] arguments = {
"-ibar", "-i", "junk", "xyz", "-jixnay", "foo", "-k", "blah", "--", "bah"
};
OptionSet options = parser.parse(arguments);
assertTrue(options.has("i"));
assertTrue(options.has("j"));
assertTrue(options.has("k"));
assertEquals(asList("bar", "junk"), options.valuesOf("i"));
assertEquals(singletonList("ixnay"), options.valuesOf("j"));
assertEquals(asList("xyz", "foo", "blah", "bah"), options.nonOptionArguments());
parser.posixlyCorrect(true);
options = parser.parse(arguments);
assertTrue(options.has("i"));
assertFalse(options.has("j"));
assertFalse(options.has("k"));
assertEquals(asList("bar", "junk"), options.valuesOf("i"));
assertEquals(emptyList(), options.valuesOf("j"));
assertEquals(
asList("xyz", "-jixnay", "foo", "-k", "blah", "--", "bah"), options.nonOptionArguments());
}
@Test
public void all() {
final List<String> values = asList("a", "b", "a", "c", "a", "d", "e");
assertTrue(Algorithms.all(values, Conditions.gte("a")));
assertTrue(Algorithms.all(values, Conditions.lt("z")));
assertTrue(Algorithms.all(values, Conditions.lte("e")));
assertFalse(Algorithms.all(values, Conditions.gt("b")));
assertFalse(Algorithms.all(values, Conditions.eq("a")));
assertFalse(Algorithms.all(values, Conditions.eq("f")));
}
@Test
public void connect_OAuth1Provider() throws Exception {
ConnectionFactoryRegistry connectionFactoryLocator = new ConnectionFactoryRegistry();
ConnectionFactory<TestApi1> connectionFactory =
new StubOAuth1ConnectionFactory("clientId", "clientSecret");
connectionFactoryLocator.addConnectionFactory(connectionFactory);
ConnectController connectController = new ConnectController(connectionFactoryLocator, null);
List<ConnectInterceptor<?>> interceptors = getConnectInterceptor();
connectController.setConnectInterceptors(interceptors);
connectController.afterPropertiesSet();
MockMvc mockMvc = standaloneSetup(connectController).build();
mockMvc
.perform(post("/connect/oauth1Provider"))
.andExpect(
redirectedUrl("https://someprovider.com/oauth/authorize?oauth_token=requestToken"))
.andExpect(
request()
.sessionAttribute(
"oauthToken",
samePropertyValuesAs(new OAuthToken("requestToken", "requestTokenSecret"))));
// Check for preConnect() only. The postConnect() won't be invoked until after callback
TestConnectInterceptor<?> textInterceptor1 = (TestConnectInterceptor<?>) (interceptors.get(0));
assertTrue(textInterceptor1.preConnectInvoked);
assertEquals("oauth1Provider", textInterceptor1.connectionFactory.getProviderId());
assertFalse(((TestConnectInterceptor<?>) (interceptors.get(1))).preConnectInvoked);
}
@Test
public void oauth2Callback() throws Exception {
ConnectionFactoryRegistry connectionFactoryLocator = new ConnectionFactoryRegistry();
ConnectionFactory<TestApi2> connectionFactory =
new StubOAuth2ConnectionFactory("clientId", "clientSecret");
connectionFactoryLocator.addConnectionFactory(connectionFactory);
StubConnectionRepository connectionRepository = new StubConnectionRepository();
ConnectController connectController =
new ConnectController(connectionFactoryLocator, connectionRepository);
List<ConnectInterceptor<?>> interceptors = getConnectInterceptor();
connectController.setConnectInterceptors(interceptors);
connectController.afterPropertiesSet();
MockMvc mockMvc = standaloneSetup(connectController).build();
assertEquals(0, connectionRepository.findConnections("oauth2Provider").size());
mockMvc
.perform(get("/connect/oauth2Provider").param("code", "oauth2Code"))
.andExpect(redirectedUrl("/connect/oauth2Provider"));
List<Connection<?>> connections = connectionRepository.findConnections("oauth2Provider");
assertEquals(1, connections.size());
assertEquals("oauth2Provider", connections.get(0).getKey().getProviderId());
// Check for postConnect() only. The preConnect() is only invoked during the initial portion of
// the flow
assertFalse(((TestConnectInterceptor<?>) (interceptors.get(0))).postConnectInvoked);
TestConnectInterceptor<?> testInterceptor2 = (TestConnectInterceptor<?>) (interceptors.get(1));
assertTrue(testInterceptor2.postConnectInvoked);
}
@Test
public void one() {
final List<String> values = asList("a", "b", "a", "c", "a", "d", "e");
assertTrue(Algorithms.one(values, Conditions.eq("c")));
assertTrue(Algorithms.one(values, Conditions.eq("a")));
assertTrue(Algorithms.one(values, Conditions.eq("e")));
assertFalse(Algorithms.one(values, Conditions.eq("f")));
}
@Test
public void getMergedAnnotationAttributesFromInterfaceImplementedBySuperclass() {
Class<?> element = ConcreteClassWithInheritedAnnotation.class;
String name = TX_NAME;
AnnotationAttributes attributes = getMergedAnnotationAttributes(element, name);
assertNull(
"Should not find @Transactional on ConcreteClassWithInheritedAnnotation", attributes);
// Verify contracts between utility methods:
assertFalse(isAnnotated(element, name));
}
@Test
public void hasMetaAnnotationTypesOnClassWithMetaDepth2() {
assertTrue(hasMetaAnnotationTypes(ComposedTransactionalComponentClass.class, TX_NAME));
assertTrue(
hasMetaAnnotationTypes(
ComposedTransactionalComponentClass.class, Component.class.getName()));
assertFalse(
hasMetaAnnotationTypes(
ComposedTransactionalComponentClass.class,
ComposedTransactionalComponent.class.getName()));
}
@Test
public void
getMergedAnnotationAttributesFavorsInheritedAnnotationsOverMoreLocallyDeclaredComposedAnnotations() {
Class<?> element = SubSubClassWithInheritedAnnotation.class;
String name = TX_NAME;
AnnotationAttributes attributes = getMergedAnnotationAttributes(element, name);
assertNotNull(
"AnnotationAttributes for @Transactional on SubSubClassWithInheritedAnnotation",
attributes);
// Verify contracts between utility methods:
assertTrue(isAnnotated(element, name));
assertFalse(
"readOnly flag for SubSubClassWithInheritedAnnotation.", attributes.getBoolean("readOnly"));
}
@Test
public void shouldLookForClassesInTargetDirectories() throws Exception {
newDir = new File("tempClassDir");
List<File> buildPaths = asList(newDir);
ClasspathProvider classpath =
new StandaloneClasspath(
buildPaths,
FakeEnvironments.systemClasspath() + pathSeparator + newDir.getAbsolutePath());
String classname = "org.fakeco.Foobar";
createClass(classname);
builder = new JavaClassBuilder(classpath);
JavaClass javaClass = builder.createClass(classname);
assertEquals(classname, javaClass.getName());
assertFalse(javaClass.isATest());
}
@Test
public void connect_OAuth2Provider() throws Exception {
ConnectionFactoryRegistry connectionFactoryLocator = new ConnectionFactoryRegistry();
ConnectionFactory<TestApi2> connectionFactory =
new StubOAuth2ConnectionFactory("clientId", "clientSecret");
connectionFactoryLocator.addConnectionFactory(connectionFactory);
ConnectController connectController = new ConnectController(connectionFactoryLocator, null);
List<ConnectInterceptor<?>> interceptors = getConnectInterceptor();
connectController.setConnectInterceptors(interceptors);
MockMvc mockMvc = standaloneSetup(connectController).build();
mockMvc.perform(post("/connect/oauth2Provider")).andExpect(redirectedUrl(OAUTH2_AUTHORIZE_URL));
// Check for preConnect() only. The postConnect() won't be invoked until after callback
assertFalse(((TestConnectInterceptor<?>) (interceptors.get(0))).preConnectInvoked);
TestConnectInterceptor<?> testInterceptor2 = (TestConnectInterceptor<?>) (interceptors.get(1));
assertTrue(testInterceptor2.preConnectInvoked);
assertEquals("oauth2Provider", testInterceptor2.connectionFactory.getProviderId());
}
@Test
public void hasMetaAnnotationTypesOnClassWithMetaDepth0() {
assertFalse(
hasMetaAnnotationTypes(
TransactionalComponentClass.class, TransactionalComponent.class.getName()));
}
public void assertTestPassed(String name) {
assertTestRun(name);
assertFalse(name + " failed! Expected to pass", testCaseEvents.get(name).failed());
}
@Test
public void isAnnotatedOnNonAnnotatedClass() {
assertFalse(isAnnotated(NonAnnotatedClass.class, TX_NAME));
}
@Test
public void isAnnotatedOnSubclassWithMetaDepth0() {
assertFalse(
"isAnnotated() does not search the class hierarchy.",
isAnnotated(SubTransactionalComponentClass.class, TransactionalComponent.class.getName()));
}
@Test
public void hasMetaAnnotationTypesOnNonAnnotatedClass() {
assertFalse(hasMetaAnnotationTypes(NonAnnotatedClass.class, TX_NAME));
}
private <T> void doNotMatch(InstanceFilter<T> filter, T candidate) {
assertFalse("filter '" + filter + "' should not match " + candidate, filter.match(candidate));
}