@Test
public void testStatisticStatistics() throws Exception {
File tempFile = File.createTempFile("ais-ab-stat-builder", "");
String outputFilename = tempFile.getCanonicalPath();
String inputDirectory = "src/test/resources";
String inputFilenamePattern = "ais-sample-micro.txt.gz";
String[] args =
new String[] {
"-inputDirectory",
inputDirectory,
"-input",
inputFilenamePattern,
"-output",
outputFilename
};
Injector injector =
Guice.createInjector(
new AbnormalStatBuilderAppTestModule(
tempFile.getCanonicalPath(), inputDirectory, inputFilenamePattern, false, 200.0));
AbnormalStatBuilderApp.setInjector(injector);
AbnormalStatBuilderApp app = injector.getInstance(AbnormalStatBuilderApp.class);
AbnormalStatBuilderApp.userArguments = parseUserArguments(args);
app.execute(new String[] {});
AppStatisticsService appStatistics = injector.getInstance(AppStatisticsService.class);
assertEquals(
(Long) 8L,
appStatistics.getStatisticStatistics("ShipTypeAndSizeStatistic", "Events processed"));
}
@Test(dataProvider = "builders")
public void testUsingInWithProvider(LifecycleInjectorBuilder lifecycleInjectorBuilder) {
Injector injector =
lifecycleInjectorBuilder
.withModules(
new Module() {
@Override
public void configure(Binder binder) {
binder.bind(LazySingletonObject.class).in(LazySingletonScope.get());
}
})
.createInjector();
Assert.assertEquals(LazySingletonObject.constructorCount.get(), 0);
Assert.assertEquals(LazySingletonObject.postConstructCount.get(), 0);
InjectedProvider injectedProvider = injector.getInstance(InjectedProvider.class);
Assert.assertEquals(LazySingletonObject.constructorCount.get(), 0);
Assert.assertEquals(LazySingletonObject.postConstructCount.get(), 0);
LazySingletonObject instance = injectedProvider.provider.get();
Assert.assertEquals(LazySingletonObject.constructorCount.get(), 1);
Assert.assertEquals(LazySingletonObject.postConstructCount.get(), 1);
LazySingletonObject instance2 = injectedProvider.provider.get();
Assert.assertEquals(LazySingletonObject.constructorCount.get(), 1);
Assert.assertEquals(LazySingletonObject.postConstructCount.get(), 1);
Assert.assertSame(instance, instance2);
}
public void register(Injector injector) {
if (!EPackage.Registry.INSTANCE.containsKey(
"http://www.eclipse.org/2011/xtext/idea/ui/common/types/xtext/ui/Refactoring")) {
EPackage.Registry.INSTANCE.put(
"http://www.eclipse.org/2011/xtext/idea/ui/common/types/xtext/ui/Refactoring",
org.eclipse
.xtext
.idea
.common
.types
.refactoringTestLanguage
.RefactoringTestLanguagePackage
.eINSTANCE);
}
org.eclipse.xtext.resource.IResourceFactory resourceFactory =
injector.getInstance(org.eclipse.xtext.resource.IResourceFactory.class);
org.eclipse.xtext.resource.IResourceServiceProvider serviceProvider =
injector.getInstance(org.eclipse.xtext.resource.IResourceServiceProvider.class);
Resource.Factory.Registry.INSTANCE
.getExtensionToFactoryMap()
.put("ideaTypesRefactoring", resourceFactory);
org.eclipse.xtext.resource.IResourceServiceProvider.Registry.INSTANCE
.getExtensionToFactoryMap()
.put("ideaTypesRefactoring", serviceProvider);
}
public void testModuleBindings() throws Exception {
Module module =
new AbstractModule() {
@Override
protected void configure() {}
@Provides
Integer fail() {
return 1;
}
};
// sanity check that the injector works
Injector injector = Guice.createInjector(module);
assertEquals(1, injector.getInstance(Integer.class).intValue());
ProviderInstanceBinding injectorBinding =
(ProviderInstanceBinding) injector.getBinding(Integer.class);
assertEquals(1, injectorBinding.getUserSuppliedProvider().get());
ProviderInstanceBinding moduleBinding =
(ProviderInstanceBinding) Iterables.getOnlyElement(Elements.getElements(module));
try {
moduleBinding.getUserSuppliedProvider().get();
fail();
} catch (IllegalStateException ise) {
assertEquals(
"This Provider cannot be used until the Injector has been created.", ise.getMessage());
}
}
public void testProviderMethodDependenciesAreExposed() throws Exception {
Module module =
new AbstractModule() {
@Override
protected void configure() {
bind(Integer.class).toInstance(50);
bindConstant().annotatedWith(Names.named("units")).to("Kg");
}
@Provides
@Named("weight")
String provideWeight(Integer count, @Named("units") String units) {
return count + units;
}
};
Injector injector = Guice.createInjector(module);
ProviderInstanceBinding<?> binding =
(ProviderInstanceBinding<?>)
injector.getBinding(Key.get(String.class, Names.named("weight")));
Method method =
module.getClass().getDeclaredMethod("provideWeight", Integer.class, String.class);
InjectionPoint point = new InjectionPoint(TypeLiteral.get(module.getClass()), method, false);
assertEquals(
ImmutableSet.<Dependency<?>>of(
new Dependency<Integer>(point, Key.get(Integer.class), false, 0),
new Dependency<String>(point, Key.get(String.class, Names.named("units")), false, 1)),
binding.getDependencies());
}
public void testToString() {
final Key<String> key1 = Key.get(String.class, Names.named("KEY"));
final Key<String> key2 = Key.get(String.class, Names.named("BAD"));
final Injector injector =
Guice.createInjector(
new AbstractModule() {
@Override
protected void configure() {
bind(key1).toProvider(new ToStringProvider());
bind(key2).toProvider(new BadToStringProvider());
}
});
final Entry<Named, String> entry1 =
new LazyBeanEntry<Named, String>(
(Named) key1.getAnnotation(), injector.getBinding(key1), 0);
final Entry<Named, String> entry2 =
new LazyBeanEntry<Named, String>(
(Named) key2.getAnnotation(), injector.getBinding(key2), 0);
Exception error = null;
try {
injector.getInstance(key2);
} catch (final Exception e) {
error = e;
}
assertEquals('@' + javax.inject.Named.class.getName() + "(value=KEY)=VALUE", entry1.toString());
assertEquals(
'@' + javax.inject.Named.class.getName() + "(value=BAD)=" + error, entry2.toString());
}
@Override
public void setUp() throws Exception {
networkManagerStub = new NetworkManagerStub();
networkManagerStub.setPort(PORT);
Injector injector = LimeTestUtils.createInjector(MyActivityCallback.class, new LimeTestUtils.NetworkManagerStubModule(networkManagerStub));
super.setUp(injector);
DownloadManagerImpl downloadManager = (DownloadManagerImpl)injector.getInstance(DownloadManager.class);
callback = (MyActivityCallback) injector.getInstance(ActivityCallback.class);
downloadManager.clearAllDownloads();
// Turn off by default, explicitly test elsewhere.
networkManagerStub.setIncomingTLSEnabled(false);
networkManagerStub.setOutgoingTLSEnabled(false);
// duplicate queries are sent out each time, so avoid the DuplicateFilter
Thread.sleep(2000);
// send a MessagesSupportedMessage
testUP[0].send(injector.getInstance(MessagesSupportedVendorMessage.class));
testUP[0].flush();
// we expect to get a PushProxy request
Message m;
do {
m = testUP[0].receive(TIMEOUT);
} while (!(m instanceof PushProxyRequest));
// we should answer the push proxy request
PushProxyAcknowledgement ack = new PushProxyAcknowledgement(InetAddress
.getLocalHost(), 6355, new GUID(m.getGUID()));
testUP[0].send(ack);
testUP[0].flush();
}
/** Transforms the {@link Statechart} model to a {@link ExecutionFlow} model */
protected ExecutionFlow createExecutionFlow(Statechart statechart, GeneratorEntry entry) {
Injector injector = getInjector(entry);
ModelSequencer sequencer = injector.getInstance(ModelSequencer.class);
ExecutionFlow flow = sequencer.transform(statechart);
Assert.isNotNull(flow, "Error creation ExecutionFlow");
FeatureConfiguration optimizeConfig = entry.getFeatureConfiguration(FUNCTION_INLINING_FEATURE);
FlowOptimizer optimizer = injector.getInstance(FlowOptimizer.class);
optimizer.inlineReactions(
getBoolValue(optimizeConfig, FUNCTION_INLINING_FEATURE_INLINE_REACTIONS, true));
optimizer.inlineExitActions(
getBoolValue(optimizeConfig, FUNCTION_INLINING_FEATURE_INLINE_EXIT_ACTIONS, true));
optimizer.inlineEntryActions(
getBoolValue(optimizeConfig, FUNCTION_INLINING_FEATURE_INLINE_ENTRY_ACTIONS, true));
optimizer.inlineEnterSequences(
getBoolValue(optimizeConfig, FUNCTION_INLINING_FEATURE_INLINE_ENTER_SEQUENCES, true));
optimizer.inlineExitSequences(
getBoolValue(optimizeConfig, FUNCTION_INLINING_FEATURE_INLINE_EXIT_SEQUENCES, true));
optimizer.inlineChoices(
getBoolValue(optimizeConfig, FUNCTION_INLINING_FEATURE_INLINE_CHOICES, true));
optimizer.inlineEntries(
getBoolValue(optimizeConfig, FUNCTION_INLINING_FEATURE_INLINE_ENTRIES, true));
optimizer.inlineEnterRegion(
getBoolValue(optimizeConfig, FUNCTION_INLINING_FEATURE_INLINE_ENTER_REGION, true));
optimizer.inlineExitRegion(
getBoolValue(optimizeConfig, FUNCTION_INLINING_FEATURE_INLINE_EXIT_REGION, true));
flow = optimizer.transform(flow);
return flow;
}
private void scanBindings() throws IOException {
for (Map.Entry<Key<?>, Binding<?>> e : globalInjector.getAllBindings().entrySet()) {
Key<?> bindingKey = e.getKey();
Binding<?> binding = e.getValue();
TypeLiteral boundTypeLiteral = bindingKey.getTypeLiteral();
Type boundType = boundTypeLiteral.getType();
if (boundType instanceof Class) {
final Class boundClass = (Class) boundType;
for (Method method : boundClass.getMethods()) {
if ((method.getModifiers() & Modifier.STATIC) == 0) {
for (Annotation annotation : method.getAnnotations()) {
if (annotation instanceof Path) {
Path pathSpec = (Path) annotation;
RouteSpec routeIn = Routes.parse(pathSpec.value(), true);
endPointMethods.add(new EndPointMethod(routeIn, bindingKey, boundClass, method));
}
}
}
}
if (MessageBodyReader.class.isAssignableFrom(boundClass)) {
messageBodyReaders.add(0, (MessageBodyReader) globalInjector.getInstance(bindingKey));
}
if (MessageBodyWriter.class.isAssignableFrom(boundClass)) {
messageBodyWriters.add(0, (MessageBodyWriter) globalInjector.getInstance(bindingKey));
}
}
}
}
@Test
public void testShippingHierarchy() {
Injector injector = Guice.createInjector(new DbModule());
PersistedClassDao persistedClassDao = injector.getInstance(PersistedClassDao.class);
ShipsTo shippingFrom = new ShipsTo("USA");
ShipsTo shippingToPak = new ShipsTo("Pakistan", 5L, 35.00);
ShipsTo shippingToEngland = new ShipsTo("England", 2L, 20.00);
ShipsTo shippingToGermany = new ShipsTo("Germany", 1L, 15.00);
Set<ShipsTo> shippingTo = new HashSet<ShipsTo>();
shippingTo.add(shippingToPak);
shippingTo.add(shippingToEngland);
shippingTo.add(shippingToGermany);
shippingFrom.setShippingTo(shippingTo);
persistedClassDao.saveInNewTransaction(shippingFrom);
ShipsTo retrievedShipping =
persistedClassDao.getEntityManager().find(ShipsTo.class, shippingFrom.getId());
Assert.assertNotNull(retrievedShipping.getId());
Set<ShipsTo> shippingsFrom = (Set<ShipsTo>) retrievedShipping.getShippingTo();
Iterator<ShipsTo> ite = shippingsFrom.iterator();
while (ite.hasNext()) {
ShipsTo shipping = ite.next();
Assert.assertNotNull(shipping.getId());
}
}
/**
* Initializes the application; in particular, bootstrapping the Isis backend, and initializing
* the {@link ComponentFactoryRegistry} to be used for rendering.
*/
@Override
protected void init() {
super.init();
// 6.0.0 rather than overriding getRequestCycleSettings
// TODO: reinstate REDIRECT_TO_RENDER once WICKET-4773 implemented (Wicket 6.1.0)
getRequestCycleSettings().setRenderStrategy(RenderStrategy.REDIRECT_TO_BUFFER);
// 6.0.0 instead of subclassing newRequestCycle
getRequestCycleListeners().add(new WebRequestCycleForIsis());
getResourceSettings().setParentFolderPlaceholder("$up$");
final DeploymentType deploymentType = determineDeploymentType();
final IsisConfigurationBuilder isisConfigurationBuilder =
createConfigBuilder(getServletContext());
final IsisInjectModule isisModule =
new IsisInjectModule(deploymentType, isisConfigurationBuilder);
final Injector injector = Guice.createInjector(isisModule, newIsisWicketModule());
injector.injectMembers(this);
this.bookmarkedPagesModel = new BookmarkedPagesModel();
initWicketComponentInjection(injector);
}
@Test
public void testSimpleCrossTxnWork() {
Session session1 = injector.getInstance(SessionFactory.class).openSession();
ManagedSessionContext.bind(session1);
HibernateTestEntity entity =
injector
.getInstance(ManualLocalTransactionsWithCustomMatchersTest.TransactionalObject.class)
.runOperationInTxn();
injector
.getInstance(ManualLocalTransactionsWithCustomMatchersTest.TransactionalObject.class)
.runOperationInTxn2();
assert injector.getInstance(Session.class).contains(entity)
: "Session appears to have been closed across txns!";
session1.close();
// try to query them back out
Session session = injector.getInstance(SessionFactory.class).openSession();
assert null
!= session
.createCriteria(HibernateTestEntity.class)
.add(Expression.eq("text", UNIQUE_TEXT))
.uniqueResult();
assert null
!= session
.createCriteria(HibernateTestEntity.class)
.add(Expression.eq("text", UNIQUE_TEXT_2))
.uniqueResult();
session.close();
}
@Test
public void testShutDown() throws Exception {
final Injector injector = Guice.createInjector(new TextExtractorModule());
final QueueListener __ = injector.getInstance(QueueListener.class);
final String fn = "/tmp/img-test-large.jpg";
Commons.copyStreamIntoFile(Commons.loadInputStreamFromSourceName("/rec02.jpg"), fn);
for (int i = 0; i < 2; i++) {
final String id = "test_msg_id_" + i;
// final String msg = "{\"receipt\":{\"id\":\"" + id + "\",\"url\":\"file://" + fn + "\"}}";
final String msg = "{\"receipt\":{\"extracted_store_name_raw_json\":null,\"img_updated_at\":\"2011-03-31T22:36:26Z\",\"img_file_size\":4816,\"extracted_store_name\":null,\"created_at\":\"2011-03-31T22:36:26Z\",\"updated_at\":\"2011-03-31T22:36:26Z\",\"url\":\"https://s3.amazonaws.com/recipitor_receipts_prod/imgs/170/medium/screenshot2.png?AWSAccessKeyId=AKIAJ77AXDKGDKTJEOMQ&Expires=1301697386&Signature=gHsq%2BuhElgDCU9RzaoK%2BqngTH2o%3D\",\"id\":"
+ "\""
+ id
+ "\""
+ ",\"user_id\":3,\"img_file_name\":\"screenshot2.png\",\"description\":null,\"img_content_type\":\"image/png\"}}";
__.REQ.sendMessage(msg);
}
final Thread t = new Thread(new Runnable() {
@Override
public void run() {
try {
__.listen();
} catch (final Exception e) {
e.printStackTrace();
Assert.fail();
}
}
});
t.start();
Thread.sleep(3000);
// __.onShutDown();
}
@Test
public void methodToMethod() throws Exception {
ShapeHelperWrapper shapeHelperWrapper = Mockito.mock(ShapeHelperWrapper.class);
UnoRuntimeWrapper unoRuntimeWrapper = Mockito.mock(UnoRuntimeWrapper.class);
XShape method1 = Mockito.mock(XShape.class);
XShape method2 = Mockito.mock(XShape.class);
Mockito.when(shapeHelperWrapper.getNodeType(method2)).thenReturn(Node.NodeType.MethodOfProcess);
XConnectorShape link = Mockito.mock(XConnectorShape.class);
XPropertySet linkPropertySet = Mockito.mock(XPropertySet.class);
Mockito.when(shapeHelperWrapper.isConnectorShape(link)).thenReturn(true);
Mockito.when(linkPropertySet.getPropertyValue(ConnectedShapes.START_SHAPE)).thenReturn(method2);
Mockito.when(linkPropertySet.getPropertyValue(ConnectedShapes.END_SHAPE)).thenReturn(method1);
Mockito.when(unoRuntimeWrapper.queryInterface(XPropertySet.class, link))
.thenReturn(linkPropertySet);
Injector injector = Guice.createInjector(new TestModule(shapeHelperWrapper, unoRuntimeWrapper));
DiagramWalker diagramWalker = injector.getInstance(DiagramWalker.class);
// diagramWalker.walk(Sets.newHashSet());
}
public RefControlTest() {
systemConfig = SystemConfig.create();
systemConfig.adminGroupId = admin;
systemConfig.anonymousGroupId = anonymous;
systemConfig.registeredGroupId = registered;
systemConfig.ownerGroupId = owners;
systemConfig.batchUsersGroupId = anonymous;
try {
byte[] bin = "abcdefghijklmnopqrstuvwxyz".getBytes("UTF-8");
systemConfig.registerEmailPrivateKey = Base64.encodeBase64String(bin);
} catch (UnsupportedEncodingException err) {
throw new RuntimeException("Cannot encode key", err);
}
Injector injector =
Guice.createInjector(
new AbstractModule() {
@Override
protected void configure() {
bind(Config.class) //
.annotatedWith(GerritServerConfig.class) //
.toInstance(new Config());
bind(SystemConfig.class).toInstance(systemConfig);
bind(AuthConfig.class);
bind(AnonymousUser.class);
}
});
authConfig = injector.getInstance(AuthConfig.class);
anonymousUser = injector.getInstance(AnonymousUser.class);
}
public static MessageRouter startMessageRouter(Injector injector) throws Exception {
String mapDesc =
"{\n"
+ " \"topic1\": {\n"
+ " \"where\": [\n"
+ " { \"sink\" : \"sink1\" },\n"
+ " { \"sink\" : \"default\" }\n"
+ " ]\n"
+ " },\n"
+ " \"topic2\": {\n"
+ " \"where\": [\n"
+ " { \"sink\" : \"sink1\" },\n"
+ " { \"sink\" : \"sink2\",\n"
+ " \"filter\" : {"
+ " \"type\" : \"regex\",\n"
+ " \"regex\" : \"1\"\n"
+ " }"
+ " }\n"
+ " ]\n"
+ " }\n"
+ "}";
RoutingMap routingMap = injector.getInstance(RoutingMap.class);
ObjectMapper mapper = injector.getInstance(ObjectMapper.class);
routingMap.set(getRoutingMap(mapper, mapDesc));
return injector.getInstance(MessageRouter.class);
}
public void testJsrNamed() {
final Named guiceNamed = Names.named("TEST");
final Injector injector =
Guice.createInjector(
new AbstractModule() {
@Override
protected void configure() {
bindConstant().annotatedWith(guiceNamed).to("CONSTANT");
}
});
@SuppressWarnings({"unchecked", "rawtypes"})
final LazyBeanEntry<javax.inject.Named, String> entry =
new LazyBeanEntry(guiceNamed, injector.getBinding(Key.get(String.class, guiceNamed)), 0);
final javax.inject.Named jsrNamed = entry.getKey();
assertTrue(jsrNamed.equals(jsrNamed));
assertTrue(jsrNamed.equals(entry.getKey()));
assertTrue(jsrNamed.equals(T.class.getAnnotation(javax.inject.Named.class)));
assertTrue(jsrNamed.equals(guiceNamed));
assertFalse(jsrNamed.equals(Names.named("")));
assertFalse(jsrNamed.equals("TEST"));
assertEquals(javax.inject.Named.class, jsrNamed.annotationType());
assertEquals(T.class.getAnnotation(javax.inject.Named.class).hashCode(), jsrNamed.hashCode());
}
@BeforeClass(groups = "slow")
protected void beforeClass() throws Exception {
final Injector injector =
Guice.createInjector(
Stage.PRODUCTION, new TestEntitlementModuleWithEmbeddedDB(configSource));
injector.injectMembers(this);
}
/** @param args */
public static void main(String[] args) {
Injector injector = Guice.createInjector(new OperationsModule());
InstructionsProcessor opsController = injector.getInstance(InstructionsProcessor.class);
setupInstructionList();
opsController.processInstructions(instructionList);
}
public final ServerStarter start(Stage stage, Consumer<ServerBuilder> consumer) {
notNull(consumer, "Null ServerBuilder consumer");
/* Create a new injector and set up the module */
final Injector injector =
Guice.createInjector(stage, (binder) -> consumer.accept(new ServerBuilder(binder)));
/* Get a hold on our HttpServer instance */
final HttpServer server = injector.getInstance(HttpServer.class);
final String serverName = server.getServerConfiguration().getName();
/* Attempt to start our server */
try {
log.info("Starting server %s", serverName);
server.start();
} catch (IOException exception) {
log.error(exception, "Exception starting server %s", serverName);
System.exit(1);
}
/* Add a shutdown hook terminating the server on exit */
Runtime.getRuntime()
.addShutdownHook(
new Thread() {
@Override
public void run() {
log.info("Shutting down server %s", serverName);
server.shutdown();
}
});
/* Return self for chaining */
this.server = server;
return this;
}
public void testNullability() throws Exception {
Module module =
new AbstractModule() {
@Override
protected void configure() {
bind(String.class).toProvider(Providers.<String>of(null));
}
@SuppressWarnings("unused")
@Provides
Integer fail(String foo) {
return 1;
}
@SuppressWarnings("unused")
@Provides
Long succeed(@Nullable String foo) {
return 2L;
}
};
Injector injector = Guice.createInjector(module);
InjectionPoint fooPoint =
InjectionPoint.forMethod(
module.getClass().getDeclaredMethod("fail", String.class),
TypeLiteral.get(module.getClass()));
Dependency<?> fooDependency = Iterables.getOnlyElement(fooPoint.getDependencies());
runNullableTest(injector, fooDependency, module);
injector.getInstance(Long.class);
}
@Test
public void shouldUseOverrideModule() {
Injector injector =
LifecycleInjector.builder()
.withRootModule(ConcurrencyModule.class)
.withBootstrapModule(
new BootstrapModule() {
@Override
public void configure(BootstrapBinder binder) {
binder
.bind(ConcurrencyModule.class)
.toInstance(
new ConcurrencyModule() {
@Override
protected void configure() {}
});
}
})
.build()
.createInjector();
try {
ScheduledExecutorService service =
injector.getInstance(Key.get(ScheduledExecutorService.class, Background.class));
Assert.fail("Binding shouldn't exist");
} catch (ConfigurationException e) {
}
}
public void testWildcardProviderMethods() {
final List<String> strings = ImmutableList.of("A", "B", "C");
final List<Number> numbers = ImmutableList.<Number>of(1, 2, 3);
Injector injector =
Guice.createInjector(
new AbstractModule() {
@Override
protected void configure() {
@SuppressWarnings("unchecked")
Key<List<? super Integer>> listOfSupertypesOfInteger =
(Key<List<? super Integer>>)
Key.get(Types.listOf(Types.supertypeOf(Integer.class)));
bind(listOfSupertypesOfInteger).toInstance(numbers);
}
@Provides
public List<? extends CharSequence> provideCharSequences() {
return strings;
}
@Provides
public Class<?> provideType() {
return Float.class;
}
});
assertSame(strings, injector.getInstance(HasWildcardInjection.class).charSequences);
assertSame(numbers, injector.getInstance(HasWildcardInjection.class).numbers);
assertSame(Float.class, injector.getInstance(HasWildcardInjection.class).type);
}
public RestTransportServer(RestContact contact, final AppServerHandler appServerHandler) {
this.contact = contact;
server = new Server(contact.getPort());
ServletContextHandler servletContextHandler = new ServletContextHandler();
servletContextHandler.setContextPath("/");
// servletContextHandler.addServlet(new ServletHolder(new
// RestTransportServlet(appServerHandler)), "/*");
servletContextHandler.addServlet(new ServletHolder(new NotFoundServlet()), "/*");
final Injector injector =
Guice.createInjector(
new ReefyServletModule(),
new AbstractModule() {
@Override
protected void configure() {
binder().requireExplicitBindings();
bind(GuiceFilter.class);
bind(new TypeLiteral<AppServerHandler<RestContact>>() {})
.toInstance(appServerHandler);
}
});
final FilterHolder guiceFilter = new FilterHolder(injector.getInstance(GuiceFilter.class));
servletContextHandler.addFilter(guiceFilter, "/*", EnumSet.allOf(DispatcherType.class));
server.setHandler(servletContextHandler);
}
/** Ensures that transactions are rolled back when a runtime exception occurs. */
public void testTransactionRolledBackOnRuntimeException() {
/*
* Create mock entity manager factory which returns a mock
* entity manager when asked.
*/
EntityManagerFactory emf = mock(EntityManagerFactory.class);
EntityManager em = mock(EntityManager.class);
when(emf.create()).thenReturn(em);
EntityTransaction tx = mock(EntityTransaction.class);
when(em.getTransaction()).thenReturn(tx);
Injector injector = Guice.createInjector(new TestModule(emf, true));
OuterTransactedClass outer = injector.getInstance(OuterTransactedClass.class);
try {
outer.doSomethingInATransaction();
fail("A runtime exception should have been thrown");
} catch (RuntimeException ignored) {
}
// emf.create should only have been called once.
verify(emf).create();
verify(tx).begin();
verify(tx).rollback();
verify(em).close();
}
/** Test setup */
@Before
public void setUp() throws Exception {
Injector injector = Guice.createInjector(new ShindigIntegratorTestsGuiceModule());
personService = injector.getInstance(ShindigIntegratorPersonService.class);
((ShindigIntegratorPersonService) personService)
.setPersistenceAdapter(new ShindigIntegratorPersistenceAdapter());
}
@SuppressWarnings("deprecation")
public void testWatchers() {
assertTrue(CItem.initialized);
assertEquals(4, namedItemWatcher.items.size());
assertEquals(2, markedItemWatcher.items.size());
assertEquals(5, annotatedItemWatcher.items.size());
assertTrue(namedItemWatcher.items.get(AItem.class.getName()) instanceof AItem);
assertTrue(namedItemWatcher.items.get(BItem.class.getName()) instanceof BItem);
assertTrue(namedItemWatcher.items.get(CItem.class.getName()) instanceof CItem);
assertTrue(namedItemWatcher.items.get(DItem.class.getName()) instanceof DItem);
assertNotSame(
namedItemWatcher.items.get(AItem.class.getName()), injector.getInstance(AItem.class));
assertSame(
namedItemWatcher.items.get(CItem.class.getName()), injector.getInstance(CItem.class));
assertTrue(markedItemWatcher.items.get(Integer.valueOf(0)) instanceof BItem);
assertTrue(markedItemWatcher.items.get(Integer.valueOf(1)) instanceof DItem);
injector.getInstance(MutableBeanLocator.class).remove(injector);
assertEquals(0, namedItemWatcher.items.size());
assertEquals(0, markedItemWatcher.items.size());
assertEquals(0, annotatedItemWatcher.items.size());
}
@Override
protected Injector getInjector() {
Properties properties = new Properties();
try {
properties.load(getClass().getClassLoader().getResourceAsStream("rideapp.properties"));
} catch (IOException e) {
throw new RuntimeException(e);
}
try {
module =
Class.forName(properties.getProperty("module.class"))
.asSubclass(BaseModule.class)
.getDeclaredConstructor(Properties.class)
.newInstance(properties);
} catch (RuntimeException e) {
throw e;
} catch (Exception e) {
throw new RuntimeException(e);
}
Injector injector = Guice.createInjector(module);
// Stupid Guice bugs 455/522
com.yrek.rideapp.servlet.UserServlet.objectMapper =
injector.getInstance(org.codehaus.jackson.map.ObjectMapper.class);
com.yrek.rideapp.servlet.UserServlet.restAPI =
injector.getInstance(com.yrek.rideapp.rest.RESTAPI.class);
com.yrek.rideapp.servlet.UserServlet.db =
injector.getInstance(com.yrek.rideapp.storage.DB.class);
return injector;
}
public void test() {
InputStream is = getClass().getResourceAsStream("/firewallService.xml");
Injector injector = Guice.createInjector(new SaxParserModule());
Factory factory = injector.getInstance(ParseSax.Factory.class);
FirewallService result =
factory.create(injector.getInstance(FirewallServiceHandler.class)).parse(is);
assertEquals(result.isEnabled(), false);
assertEquals(
result.getFirewallRules(),
ImmutableSet.<FirewallRule>of(
FirewallRule.builder()
.firewallType("SERVER_TIER_FIREWALL")
.isEnabled(false)
.source("internet")
.destination("VM Tier01")
.port("22")
.protocol("Tcp")
.policy("allow")
.description("Server Tier Firewall Rule")
.isLogged(false)
.build(),
FirewallRule.builder()
.firewallType("SERVER_TIER_FIREWALL")
.isEnabled(true)
.source("VM Tier03")
.destination("VM Tier03")
.protocol("Icmp-ping")
.policy("allow")
.description("Server Tier Firewall Rule")
.isLogged(false)
.build()));
}
@Test
public void testGetEmitterViaRealGuice() {
Injector injector =
Guice.createInjector(
new DruidGuiceExtensions(),
new LifecycleModule(),
new Module() {
@Override
public void configure(Binder binder) {
Properties props = new Properties();
props.put("druid.emitter.composing.emitters", "[\"" + testEmitterType + "\"]");
binder.bind(Properties.class).toInstance(props);
binder
.bind(Validator.class)
.toInstance(Validation.buildDefaultValidatorFactory().getValidator());
binder
.bind(Emitter.class)
.annotatedWith(Names.named(testEmitterType))
.toInstance(emitter);
}
},
new ComposingEmitterModule());
injector.getInstance(Key.get(Emitter.class, Names.named("composing"))).start();
EasyMock.verify(emitter);
}
