Java Code Examples for javax.naming.spi.NamingManager#setInitialContextFactoryBuilder()

/**
 * Register the context builder by registering it with the JNDI NamingManager.
 * Note that once this has been done, {@code new InitialContext()} will always
 * return a context from this factory. Use the {@code emptyActivatedContextBuilder()}
 * static method to get an empty context (for example, in test methods).
 * @throws IllegalStateException if there's already a naming context builder
 * registered with the JNDI NamingManager
 */
public void activate() throws IllegalStateException, NamingException {
	logger.info("Activating simple JNDI environment");
	synchronized (initializationLock) {
		if (!initialized) {
			if (NamingManager.hasInitialContextFactoryBuilder()) {
				throw new IllegalStateException(
						"Cannot activate SimpleNamingContextBuilder: there is already a JNDI provider registered. " +
						"Note that JNDI is a JVM-wide service, shared at the JVM system class loader level, " +
						"with no reset option. As a consequence, a JNDI provider must only be registered once per JVM.");
			}
			NamingManager.setInitialContextFactoryBuilder(this);
			initialized = true;
		}
	}
	activated = this;
}
 

/**
 * Register the context builder by registering it with the JNDI NamingManager.
 * Note that once this has been done, {@code new InitialContext()} will always
 * return a context from this factory. Use the {@code emptyActivatedContextBuilder()}
 * static method to get an empty context (for example, in test methods).
 * @throws IllegalStateException if there's already a naming context builder
 * registered with the JNDI NamingManager
 */
public void activate() throws IllegalStateException, NamingException {
	logger.info("Activating simple JNDI environment");
	synchronized (initializationLock) {
		if (!initialized) {
			if (NamingManager.hasInitialContextFactoryBuilder()) {
				throw new IllegalStateException(
						"Cannot activate SimpleNamingContextBuilder: there is already a JNDI provider registered. " +
						"Note that JNDI is a JVM-wide service, shared at the JVM system class loader level, " +
						"with no reset option. As a consequence, a JNDI provider must only be registered once per JVM.");
			}
			NamingManager.setInitialContextFactoryBuilder(this);
			initialized = true;
		}
	}
	activated = this;
}
 

@Before
public void setup() throws Exception {

    // container.enableInterfaceMocking(true);
    if (!NamingManager.hasInitialContextFactoryBuilder()) {
        NamingManager
                .setInitialContextFactoryBuilder(new TestNamingContextFactoryBuilder());
    }
    InitialContext initialContext = new InitialContext();
    Properties properties = new Properties();
    properties.put("mail.from", "[email protected]");
    mailMock = Session.getInstance(properties);
    initialContext.bind("mail/BSSMail", mailMock);
    configurationService = mock(APPConfigurationServiceBean.class);
    commService = spy(new APPCommunicationServiceBean());
    commService.configService = configurationService;
    doNothing().when(commService).transportMail(
            Matchers.any(MimeMessage.class));
}
 

@BeforeClass
public static void beforeClass() throws Exception {
    URL sqlProperties = Thread.currentThread().getContextClassLoader().getResource("sqlg.properties");
    configuration = new PropertiesConfiguration(sqlProperties);
    if (!configuration.containsKey("jdbc.url")) {
        throw new IllegalArgumentException(String.format("SqlGraph configuration requires that the %s be set", "jdbc.url"));
    }

    ds = C3P0DataSource.create(configuration).getDatasource();

    //change the connection url to be a JNDI one
    configuration.setProperty("jdbc.url", "jndi:testConnection");

    //set up the initial context
    NamingManager.setInitialContextFactoryBuilder(environment -> {
        InitialContextFactory mockFactory = mock(InitialContextFactory.class);
        Context mockContext = mock(Context.class);
        when(mockFactory.getInitialContext(any())).thenReturn(mockContext);

        when(mockContext.lookup("testConnection")).thenReturn(ds);

        return mockFactory;
    });
}
 

/**
 * Will create a JNDI Context and register it as the initial context factory builder
 *
 * @return the context
 * @throws NamingException
 *                             on any issue during initial context factory builder registration
 */
static JndiContext createJndiContext() throws NamingException
{
    try
    {
        if (!NamingManager.hasInitialContextFactoryBuilder())
        {
            JndiContext ctx = new JndiContext();
            NamingManager.setInitialContextFactoryBuilder(ctx);
            return ctx;
        }
        else
        {
            return (JndiContext) NamingManager.getInitialContext(null);
        }
    }
    catch (Exception e)
    {
        jqmlogger.error("Could not create JNDI context: " + e.getMessage());
        NamingException ex = new NamingException("Could not initialize JNDI Context");
        ex.setRootCause(e);
        throw ex;
    }
}
 

@Before
public void setUp() throws Exception {
  Locale.setDefault( Locale.US );
  TimeZone.setDefault( TimeZone.getTimeZone( "UTC" ) );
  // enforce binary compatibility for the xml-files so that comparing them can be faster.

  ClassicEngineBoot.getInstance().start();
  if ( NamingManager.hasInitialContextFactoryBuilder() == false ) {
    NamingManager.setInitialContextFactoryBuilder( new DebugJndiContextFactoryBuilder() );
  }

  localFontRegistry = new LocalFontRegistry();
  localFontRegistry.initialize();
}
 

/**
 * Register the context builder by registering it with the JNDI NamingManager.
 * Note that once this has been done, {@code new InitialContext()} will always
 * return a context from this factory. Use the {@code emptyActivatedContextBuilder()}
 * static method to get an empty context (for example, in test methods).
 * @throws IllegalStateException if there's already a naming context builder
 * registered with the JNDI NamingManager
 */
public void activate() throws IllegalStateException, NamingException {
	logger.info("Activating simple JNDI environment");
	synchronized (initializationLock) {
		if (!initialized) {
			Assert.state(!NamingManager.hasInitialContextFactoryBuilder(),
						"Cannot activate SimpleNamingContextBuilder: there is already a JNDI provider registered. " +
						"Note that JNDI is a JVM-wide service, shared at the JVM system class loader level, " +
						"with no reset option. As a consequence, a JNDI provider must only be registered once per JVM.");
			NamingManager.setInitialContextFactoryBuilder(this);
			initialized = true;
		}
	}
	activated = this;
}
 

@Before
public void setUp() throws Exception {
  ClassicEngineBoot.getInstance().start();
  if ( NamingManager.hasInitialContextFactoryBuilder() == false ) {
    NamingManager.setInitialContextFactoryBuilder( new DebugJndiContextFactoryBuilder() );
  }
}
 

@Before
public void setUp() throws Exception {
  conn = mockConnection( mock( DatabaseMetaData.class ) );
  when( log.getLogLevel() ).thenReturn( LogLevel.NOTHING );
  when( dbMetaMock.getDatabaseInterface() ).thenReturn( databaseInterface );
  if ( !NamingManager.hasInitialContextFactoryBuilder() ) {
    // If JNDI is not initialized, use simpleJNDI
    System.setProperty( Context.INITIAL_CONTEXT_FACTORY,
      "org.osjava.sj.memory.MemoryContextFactory" ); // pentaho#simple-jndi;1.0.0
    System.setProperty( "org.osjava.sj.jndi.shared", "true" );
    InitialContextFactoryBuilder simpleBuilder = new SimpleNamingContextBuilder();
    NamingManager.setInitialContextFactoryBuilder( simpleBuilder );
  }
}
 

@Before
public void setUp() throws Exception {
  ClassicEngineBoot.getInstance().start();
  if ( NamingManager.hasInitialContextFactoryBuilder() == false ) {
    NamingManager.setInitialContextFactoryBuilder( new DebugJndiContextFactoryBuilder() );
  }
}
 

@Test
public void testQueryFallback() throws Exception {
  PooledWithJndiDataSourceService service = new PooledWithJndiDataSourceService();
  NamingManager.setInitialContextFactoryBuilder( new DebugJndiContextFactoryBuilder() );

  DataSource ds = service.queryFallback( "SampleData" );

  assertThat( ds, is( notNullValue() ) );
  assertThat( ds.getConnection(), is( notNullValue() ) );
}
 

@Before
public void setUp() throws Exception {
  ClassicEngineBoot.getInstance().start();
  if ( NamingManager.hasInitialContextFactoryBuilder() == false ) {
    NamingManager.setInitialContextFactoryBuilder( new DebugJndiContextFactoryBuilder() );
  }
}
 

@Before
public void setUp() throws Exception {
  ClassicEngineBoot.getInstance().start();
  if ( NamingManager.hasInitialContextFactoryBuilder() == false ) {
    NamingManager.setInitialContextFactoryBuilder( new DebugJndiContextFactoryBuilder() );
  }
}
 

/**
 * Register the context builder by registering it with the JNDI NamingManager.
 * Note that once this has been done, {@code new InitialContext()} will always
 * return a context from this factory. Use the {@code emptyActivatedContextBuilder()}
 * static method to get an empty context (for example, in test methods).
 * @throws IllegalStateException if there's already a naming context builder
 * registered with the JNDI NamingManager
 */
public void activate() throws IllegalStateException, NamingException {
	logger.info("Activating simple JNDI environment");
	synchronized (initializationLock) {
		if (!initialized) {
			Assert.state(!NamingManager.hasInitialContextFactoryBuilder(),
						"Cannot activate SimpleNamingContextBuilder: there is already a JNDI provider registered. " +
						"Note that JNDI is a JVM-wide service, shared at the JVM system class loader level, " +
						"with no reset option. As a consequence, a JNDI provider must only be registered once per JVM.");
			NamingManager.setInitialContextFactoryBuilder(this);
			initialized = true;
		}
	}
	activated = this;
}
 

public void setUp() throws Exception {
  ClassicEngineBoot.getInstance().start();
  if ( NamingManager.hasInitialContextFactoryBuilder() == false ) {
    NamingManager.setInitialContextFactoryBuilder( new DebugJndiContextFactoryBuilder() );
  }
}
 

protected void setUp() throws Exception {
  ClassicEngineBoot.getInstance().start();
  if ( NamingManager.hasInitialContextFactoryBuilder() == false ) {
    NamingManager.setInitialContextFactoryBuilder( new DebugJndiContextFactoryBuilder() );
  }
}
 

public void setUp() throws Exception {
  ClassicEngineBoot.getInstance().start();
  if ( NamingManager.hasInitialContextFactoryBuilder() == false ) {
    NamingManager.setInitialContextFactoryBuilder( new DebugJndiContextFactoryBuilder() );
  }
}
 

public void setUp() throws Exception {
  ClassicEngineBoot.getInstance().start();
  if ( NamingManager.hasInitialContextFactoryBuilder() == false ) {
    NamingManager.setInitialContextFactoryBuilder( new DebugJndiContextFactoryBuilder() );
  }
}
 

protected void setUp() throws Exception {
  ClassicEngineBoot.getInstance().start();
  if ( NamingManager.hasInitialContextFactoryBuilder() == false ) {
    NamingManager.setInitialContextFactoryBuilder( new DebugJndiContextFactoryBuilder() );
  }
}
 

/**
 * Tries to register a mocked <code>NamingContextFactoryBuilder</code> to
 * enable basic JNDI functionality in the test code.
 * 
 * @throws NamingException
 * @see {@link TestNamingContext}
 */
protected static void enableJndiMock() throws NamingException {
    if (!NamingManager.hasInitialContextFactoryBuilder()) {
        NamingManager
                .setInitialContextFactoryBuilder(new TestNamingContextFactoryBuilder(PERSISTENCE));
    }
}