def tearDown(self):
"""
Cleans up the test environment
"""
# Stop the framework
FrameworkFactory.delete_framework()
self.framework = None
def testWaitForStop(self):
"""
Tests the wait_for_stop() method
"""
# Set up a framework
framework = FrameworkFactory.get_framework()
# No need to wait for the framework...
self.assertTrue(framework.wait_for_stop(),
"wait_for_stop() must return True "
"on stopped framework")
# Start the framework
framework.start()
# Start the framework killer
threading.Thread(target=_framework_killer,
args=(framework, 0.5)).start()
# Wait for stop
start = time.time()
self.assertTrue(framework.wait_for_stop(),
"wait_for_stop(None) should return True")
end = time.time()
self.assertLess(end - start, 1, "Wait should be less than 1 sec")
FrameworkFactory.delete_framework(framework)
def tearDown(self):
"""
Called after each test
"""
self.framework.stop()
FrameworkFactory.delete_framework()
self.framework = None
def testFrameworkRestart(self):
"""
Tests call to Framework.update(), that restarts the framework
"""
framework = FrameworkFactory.get_framework()
context = framework.get_bundle_context()
# Register the stop listener
context.add_framework_stop_listener(self)
# Calling update while the framework is stopped should do nothing
framework.update()
self.assertFalse(self.stopping, "Stop listener called")
# Start and update the framework
self.assertTrue(framework.start(), "Framework couldn't be started")
framework.update()
# The framework must have been stopped and must be active
self.assertTrue(self.stopping, "Stop listener not called")
self.assertEqual(framework.get_state(), Bundle.ACTIVE,
"Framework hasn't been restarted")
framework.stop()
FrameworkFactory.delete_framework(framework)
def testBundleStart(self):
"""
Tests if a bundle can be started before the framework itself
"""
framework = FrameworkFactory.get_framework()
context = framework.get_bundle_context()
assert isinstance(context, BundleContext)
# Install a bundle
bundle = context.install_bundle(SIMPLE_BUNDLE)
self.assertEqual(bundle.get_state(), Bundle.RESOLVED, "Bundle should be in RESOLVED state")
# Starting the bundle now should fail
self.assertRaises(BundleException, bundle.start)
self.assertEqual(bundle.get_state(), Bundle.RESOLVED, "Bundle should be in RESOLVED state")
# Start the framework
framework.start()
# Bundle should have been started now
self.assertEqual(bundle.get_state(), Bundle.ACTIVE, "Bundle should be in ACTIVE state")
# Stop the framework
framework.stop()
self.assertEqual(bundle.get_state(), Bundle.RESOLVED, "Bundle should be in RESOLVED state")
# Try to start the bundle again (must fail)
self.assertRaises(BundleException, bundle.start)
self.assertEqual(bundle.get_state(), Bundle.RESOLVED, "Bundle should be in RESOLVED state")
FrameworkFactory.delete_framework()
def testAddedProperty(self):
"""
Tests the add_property method
"""
pelix_test_name = "PELIX_TEST"
pelix_test = "42"
pelix_test_2 = "123"
# Test without pre-set properties
framework = FrameworkFactory.get_framework()
self.assertIsNone(framework.get_property(pelix_test_name),
"Magic property value")
# Add the property
self.assertTrue(framework.add_property(pelix_test_name, pelix_test),
"add_property shouldn't fail on first call")
self.assertEqual(framework.get_property(pelix_test_name), pelix_test,
"Invalid property value")
# Update the property (must fail)
self.assertFalse(framework.add_property(pelix_test_name, pelix_test_2),
"add_property must fail on second call")
self.assertEqual(framework.get_property(pelix_test_name), pelix_test,
"Invalid property value")
FrameworkFactory.delete_framework(framework)
def testCreateFrameworkAutoStart(self):
"""
Tests create_framework(), with specified bundles and auto-start
"""
# Without bundles
self.framework = pelix.create_framework([], auto_start=True)
self.assertEqual(self.framework.get_state(), pelix.Bundle.ACTIVE,
"Framework hasn't been started")
self.assertEqual(self.framework.get_bundles(), [],
'Framework is not empty')
# Clean up
FrameworkFactory.delete_framework()
# With bundles
self.framework = pelix.create_framework([self.test_bundle_name],
auto_start=True)
self.assertEqual(self.framework.get_state(), pelix.Bundle.ACTIVE,
"Framework hasn't been started")
self.assertEqual(len(self.framework.get_bundles()), 1,
'Framework should only have 1 bundle')
bundle = self.framework.get_bundle_by_id(1)
self.assertEqual(bundle.get_symbolic_name(), self.test_bundle_name,
"The test bundle hasn't been installed correctly")
self.assertEqual(bundle.get_state(), pelix.Bundle.ACTIVE,
"Bundle hasn't been started")
def test_init_bundle_loader_with_running_framework(delete_framework):
"""
Tests that creating a Loader instance with an already running Pelix
framework will work and enforce a correct configuration of the framework.
"""
framework = pelix.framework.create_framework(())
assert framework.get_bundle_by_name("pelix.ipopo.core") is None
assert FrameworkFactory.is_framework_running()
# Creating a loader instance where existing framework misses
# pelix.ipopo.core bundle.
# This bundle is expected to be added to the framework at Loader
# initialization
loader = BundleLoader()
assert framework is loader.framework
assert loader.framework.get_bundle_by_name("pelix.ipopo.core") is not None
del loader
# Same as above, but now, existing framework HAS pelix.ipopo.core bundle
loader = BundleLoader()
assert framework is loader.framework
assert loader.framework.get_bundle_by_name("pelix.ipopo.core") is not None
del loader
# Framework outlives the Loader
assert FrameworkFactory.is_framework_running()
def tearDown(self):
"""
Called after each test
"""
if self.framework is not None:
FrameworkFactory.delete_framework(self.framework)
self.framework = None
def testAddedProperty(self):
"""
Tests the add_property method
"""
pelix_test_name = "PELIX_TEST"
pelix_test = "42"
pelix_test_2 = "123"
# Test without pre-set properties
framework = FrameworkFactory.get_framework()
self.assertIsNone(framework.get_property(pelix_test_name),
"Magic property value")
# Add the property
self.assertTrue(framework.add_property(pelix_test_name, pelix_test),
"add_property shouldn't fail on first call")
self.assertEqual(framework.get_property(pelix_test_name), pelix_test,
"Invalid property value")
# Update the property (must fail)
self.assertFalse(framework.add_property(pelix_test_name, pelix_test_2),
"add_property must fail on second call")
self.assertEqual(framework.get_property(pelix_test_name), pelix_test,
"Invalid property value")
FrameworkFactory.delete_framework()
def tearDown(self):
"""
Cleans up the test environment
"""
# Stop the framework
FrameworkFactory.delete_framework()
self.framework = None
def testCreateFrameworkAutoStart(self):
"""
Tests create_framework(), with specified bundles and auto-start
"""
# Without bundles
self.framework = pelix.create_framework([], auto_start=True)
self.assertEqual(self.framework.get_state(), pelix.Bundle.ACTIVE,
"Framework hasn't been started")
self.assertEqual(self.framework.get_bundles(), [],
'Framework is not empty')
# Clean up
FrameworkFactory.delete_framework(self.framework)
# With bundles
self.framework = pelix.create_framework([self.test_bundle_name],
auto_start=True)
self.assertEqual(self.framework.get_state(), pelix.Bundle.ACTIVE,
"Framework hasn't been started")
self.assertEqual(len(self.framework.get_bundles()), 1,
'Framework should only have 1 bundle')
bundle = self.framework.get_bundle_by_id(1)
self.assertEqual(bundle.get_symbolic_name(), self.test_bundle_name,
"The test bundle hasn't been installed correctly")
self.assertEqual(bundle.get_state(), pelix.Bundle.ACTIVE,
"Bundle hasn't been started")
def testWaitForStop(self):
"""
Tests the wait_for_stop() method
"""
# Set up a framework
framework = FrameworkFactory.get_framework()
# No need to wait for the framework...
self.assertTrue(
framework.wait_for_stop(), "wait_for_stop() must return True "
"on stopped framework")
# Start the framework
framework.start()
# Start the framework killer
threading.Thread(target=_framework_killer,
args=(framework, 0.5)).start()
# Wait for stop
start = time.time()
self.assertTrue(framework.wait_for_stop(),
"wait_for_stop(None) should return True")
end = time.time()
self.assertLess(end - start, 1, "Wait should be less than 1 sec")
FrameworkFactory.delete_framework()
def testFrameworkRestart(self):
"""
Tests call to Framework.update(), that restarts the framework
"""
framework = FrameworkFactory.get_framework()
context = framework.get_bundle_context()
# Register the stop listener
context.add_framework_stop_listener(self)
# Calling update while the framework is stopped should do nothing
framework.update()
self.assertFalse(self.stopping, "Stop listener called")
# Start and update the framework
self.assertTrue(framework.start(), "Framework couldn't be started")
framework.update()
# The framework must have been stopped and must be active
self.assertTrue(self.stopping, "Stop listener not called")
self.assertEqual(framework.get_state(), Bundle.ACTIVE,
"Framework hasn't been restarted")
framework.stop()
FrameworkFactory.delete_framework()
def tearDown(self):
"""
Called after each test
"""
if self.framework is not None:
FrameworkFactory.delete_framework()
self.framework = None
def testWaitForStopTimeout(self):
"""
Tests the wait_for_stop() method
"""
# Set up a framework
framework = FrameworkFactory.get_framework()
framework.start()
# Start the framework killer
threading.Thread(target=_framework_killer, args=(framework, 0.5)).start()
# Wait for stop (timeout not raised)
start = time.time()
self.assertTrue(framework.wait_for_stop(1), "wait_for_stop() should return True")
end = time.time()
self.assertLess(end - start, 1, "Wait should be less than 1 sec")
# Restart framework
framework.start()
# Start the framework killer
threading.Thread(target=_framework_killer, args=(framework, 2)).start()
# Wait for stop (timeout raised)
start = time.time()
self.assertFalse(framework.wait_for_stop(1), "wait_for_stop() should return False")
end = time.time()
self.assertLess(end - start, 1.2, "Wait should be less than 1.2 sec")
# Wait for framework to really stop
framework.wait_for_stop()
FrameworkFactory.delete_framework()
def tearDown(self):
"""
Called after each test
"""
# Destroy the framework
FrameworkFactory.delete_framework()
self.framework = None
self.waiting = None
def tearDown(self):
"""
Called after each test
"""
# Destroy the framework
FrameworkFactory.delete_framework()
self.framework = None
self.waiting = None
def tearDown(self):
"""
Cleans up the framework
"""
self.framework.stop()
FrameworkFactory.delete_framework()
self.utility = None
self.context = None
self.framework = None
def tearDown(self):
"""
Cleans up the framework
"""
self.framework.stop()
FrameworkFactory.delete_framework()
self.remote = None
self.shell = None
self.framework = None
def tearDown(self):
"""
Cleans up the framework
"""
self.framework.stop()
FrameworkFactory.delete_framework()
self.utility = None
self.context = None
self.framework = None
def tearDown(self):
"""
Called after each test
"""
self.framework.stop()
FrameworkFactory.delete_framework()
# Reset the environment variable
os.environ['bundle.import.fail'] = "0"
def tearDown(self):
"""
Called after each test
"""
self.framework.stop()
FrameworkFactory.delete_framework()
# Reset the environment variable
os.environ['bundle.import.fail'] = "0"
def tearDown(self):
"""
Called after each test
"""
self.framework.stop()
FrameworkFactory.delete_framework(self.framework)
# Clean up
self.ipopo = None
self.framework = None
def tearDown(self):
"""
Called after each test
"""
self.framework.stop()
FrameworkFactory.delete_framework(self.framework)
# Clean up
self.ipopo = None
self.framework = None
def tearDown(self):
"""
Cleans up the framework
"""
self.framework.stop()
FrameworkFactory.delete_framework()
self.shell = None
self.context = None
self.framework = None
self._flag = False
def tearDown(self):
"""
Cleans up the framework
"""
self.framework.stop()
FrameworkFactory.delete_framework()
self.shell = None
self.context = None
self.framework = None
self._flag = False
def testFrameworkStopper(self):
"""
Tests FrameworkException stop flag handling
"""
framework = FrameworkFactory.get_framework()
context = framework.get_bundle_context()
# Install the bundle
bundle = context.install_bundle(SIMPLE_BUNDLE)
module = bundle.get_module()
# Set module in raiser stop mode
module.fw_raiser = True
module.fw_raiser_stop = True
log_off()
self.assertFalse(framework.start(), "Framework should be stopped")
self.assertEqual(framework.get_state(), Bundle.RESOLVED,
"Framework should be stopped")
self.assertEqual(bundle.get_state(), Bundle.RESOLVED,
"Bundle should be stopped")
log_on()
# Set module in raiser non-stop mode
module.fw_raiser_stop = False
log_off()
self.assertTrue(framework.start(), "Framework should be stopped")
self.assertEqual(framework.get_state(), Bundle.ACTIVE,
"Framework should be started")
self.assertEqual(bundle.get_state(), Bundle.RESOLVED,
"Bundle should be stopped")
log_on()
# Start the module
module.fw_raiser = False
bundle.start()
self.assertEqual(bundle.get_state(), Bundle.ACTIVE,
"Bundle should be active")
# Set module in raiser mode
module.fw_raiser = True
module.fw_raiser_stop = True
# Stop the framework
log_off()
self.assertTrue(framework.stop(), "Framework couldn't be stopped")
self.assertEqual(framework.get_state(), Bundle.RESOLVED,
"Framework should be stopped")
self.assertEqual(bundle.get_state(), Bundle.RESOLVED,
"Bundle should be stopped")
log_on()
FrameworkFactory.delete_framework(framework)
def testFrameworkStopper(self):
"""
Tests FrameworkException stop flag handling
"""
framework = FrameworkFactory.get_framework()
context = framework.get_bundle_context()
# Install the bundle
bundle = context.install_bundle(SIMPLE_BUNDLE)
module_ = bundle.get_module()
# Set module in raiser stop mode
module_.fw_raiser = True
module_.fw_raiser_stop = True
log_off()
self.assertFalse(framework.start(), "Framework should be stopped")
self.assertEqual(framework.get_state(), Bundle.RESOLVED,
"Framework should be stopped")
self.assertEqual(bundle.get_state(), Bundle.RESOLVED,
"Bundle should be stopped")
log_on()
# Set module in raiser non-stop mode
module_.fw_raiser_stop = False
log_off()
self.assertTrue(framework.start(), "Framework should be stopped")
self.assertEqual(framework.get_state(), Bundle.ACTIVE,
"Framework should be started")
self.assertEqual(bundle.get_state(), Bundle.RESOLVED,
"Bundle should be stopped")
log_on()
# Start the module
module_.fw_raiser = False
bundle.start()
self.assertEqual(bundle.get_state(), Bundle.ACTIVE,
"Bundle should be active")
# Set module in raiser mode
module_.fw_raiser = True
module_.fw_raiser_stop = True
# Stop the framework
log_off()
self.assertTrue(framework.stop(), "Framework couldn't be stopped")
self.assertEqual(framework.get_state(), Bundle.RESOLVED,
"Framework should be stopped")
self.assertEqual(bundle.get_state(), Bundle.RESOLVED,
"Bundle should be stopped")
log_on()
FrameworkFactory.delete_framework()
def testFrameworkStartRaiser(self):
"""
Tests framework start and stop with a bundle raising exception
"""
framework = FrameworkFactory.get_framework()
context = framework.get_bundle_context()
# Register the stop listener
context.add_framework_stop_listener(self)
# Install the bundle
bundle = context.install_bundle(SIMPLE_BUNDLE)
module = bundle.get_module()
# Set module in raiser mode
module.raiser = True
# Framework can start...
log_off()
self.assertTrue(framework.start(), "Framework should be started")
log_on()
self.assertEqual(framework.get_state(), Bundle.ACTIVE,
"Framework should be in ACTIVE state")
self.assertEqual(bundle.get_state(), Bundle.RESOLVED,
"Bundle should be in RESOLVED state")
# Stop the framework
self.assertTrue(framework.stop(), "Framework should be stopped")
# Remove raiser mode
module.raiser = False
# Framework can start
self.assertTrue(framework.start(), "Framework couldn't be started")
self.assertEqual(framework.get_state(), Bundle.ACTIVE,
"Framework should be in ACTIVE state")
self.assertEqual(bundle.get_state(), Bundle.ACTIVE,
"Bundle should be in ACTIVE state")
# Set module in raiser mode
module.raiser = True
# Stop the framework
log_off()
self.assertTrue(framework.stop(), "Framework couldn't be stopped")
log_on()
self.assertTrue(self.stopping, "Stop listener not called")
FrameworkFactory.delete_framework(framework)
def testFrameworkStartRaiser(self):
"""
Tests framework start and stop with a bundle raising exception
"""
framework = FrameworkFactory.get_framework()
context = framework.get_bundle_context()
# Register the stop listener
context.add_framework_stop_listener(self)
# Install the bundle
bundle = context.install_bundle(SIMPLE_BUNDLE)
module_ = bundle.get_module()
# Set module in raiser mode
module_.raiser = True
# Framework can start...
log_off()
self.assertTrue(framework.start(), "Framework should be started")
log_on()
self.assertEqual(framework.get_state(), Bundle.ACTIVE,
"Framework should be in ACTIVE state")
self.assertEqual(bundle.get_state(), Bundle.RESOLVED,
"Bundle should be in RESOLVED state")
# Stop the framework
self.assertTrue(framework.stop(), "Framework should be stopped")
# Remove raiser mode
module_.raiser = False
# Framework can start
self.assertTrue(framework.start(), "Framework couldn't be started")
self.assertEqual(framework.get_state(), Bundle.ACTIVE,
"Framework should be in ACTIVE state")
self.assertEqual(bundle.get_state(), Bundle.ACTIVE,
"Bundle should be in ACTIVE state")
# Set module in raiser mode
module_.raiser = True
# Stop the framework
log_off()
self.assertTrue(framework.stop(), "Framework couldn't be stopped")
log_on()
self.assertTrue(self.stopping, "Stop listener not called")
FrameworkFactory.delete_framework()
def testBundleZero(self):
"""
Tests if bundle 0 is the framework
"""
framework = FrameworkFactory.get_framework()
self.assertIsNone(framework.get_bundle_by_name(None), "None name is not bundle 0")
self.assertIs(framework, framework.get_bundle_by_id(0), "Invalid bundle 0")
pelix_name = framework.get_symbolic_name()
self.assertIs(framework, framework.get_bundle_by_name(pelix_name), "Invalid system bundle name")
FrameworkFactory.delete_framework()
def testUninstall(self):
"""
Tests if the framework raises an exception if uninstall() is called
"""
# Set up a framework
framework = FrameworkFactory.get_framework()
self.assertRaises(BundleException, framework.uninstall)
# Even once started...
framework.start()
self.assertRaises(BundleException, framework.uninstall)
framework.stop()
FrameworkFactory.delete_framework()
def testUninstall(self):
"""
Tests if the framework raises an exception if uninstall() is called
"""
# Set up a framework
framework = FrameworkFactory.get_framework()
self.assertRaises(BundleException, framework.uninstall)
# Even once started...
framework.start()
self.assertRaises(BundleException, framework.uninstall)
framework.stop()
FrameworkFactory.delete_framework(framework)
def tearDown(self):
"""
Cleans up the framework
"""
self.framework.stop()
FrameworkFactory.delete_framework()
# Remove the output file
if os.path.exists(self.out_file):
os.remove(self.out_file)
self.report = None
self.shell = None
self.context = None
self.framework = None
def framework(self) -> Framework:
"""
The currently running Pelix framework instance, or a new one if none is running (anyway,
the framework instance will continue after deletion of this BundleLoader instance)
"""
if FrameworkFactory.is_framework_running():
self._framework = FrameworkFactory.get_framework()
# Do not use self.context, because it will call back this.
context = self._framework.get_bundle_context()
if not context.get_service_reference(SERVICE_IPOPO):
self._framework.install_bundle(SERVICE_IPOPO)
else:
self._framework = pelix.framework.create_framework(())
self._framework.install_bundle(SERVICE_IPOPO)
self._framework.start()
return self._framework
def testDuplicatedFactory(self):
"""
Tests the behavior of iPOPO if two bundles provide the same factory.
"""
# Start the framework
self.framework = FrameworkFactory.get_framework()
self.framework.start()
ipopo = install_ipopo(self.framework)
# Install bundles: both provide a "basic-component-factory" factory
# and instantiate a component (both with different names)
module_A = install_bundle(self.framework, "tests.ipopo.ipopo_bundle")
module_B = install_bundle(self.framework,
"tests.ipopo.ipopo_bundle_copy")
# Ensure that the module providing the factory is the correct one
self.assertIs(module_A,
ipopo.get_factory_bundle(
module_A.BASIC_FACTORY).get_module(),
"Duplicated factory is not provided by the first module")
self.assertIs(module_A,
ipopo.get_factory_bundle(
module_B.BASIC_FACTORY).get_module(),
"Duplicated factory is not provided by the first module")
# Component of module A must be there
self.assertIsNotNone(
ipopo.get_instance_details(module_A.BASIC_INSTANCE),
"Component from module A not started")
# Component of module B must be absent
self.assertRaises(ValueError,
ipopo.get_instance_details, module_B.BASIC_INSTANCE)
def setUp(self):
"""
Called before each test. Initiates a framework.
"""
self.framework = FrameworkFactory.get_framework()
self.framework.start()
self.ipopo_bundle = install_bundle(self.framework, "pelix.ipopo.core")
def testDuplicatedFactory(self):
"""
Tests the behavior of iPOPO if two bundles provide the same factory.
"""
# Start the framework
self.framework = FrameworkFactory.get_framework()
self.framework.start()
ipopo = install_ipopo(self.framework)
# Install bundles: both provide a "basic-component-factory" factory
# and instantiate a component (both with different names)
module_A = install_bundle(self.framework, "tests.ipopo.ipopo_bundle")
module_B = install_bundle(self.framework,
"tests.ipopo.ipopo_bundle_copy")
# Ensure that the module providing the factory is the correct one
self.assertIs(
module_A,
ipopo.get_factory_bundle(module_A.BASIC_FACTORY).get_module(),
"Duplicated factory is not provided by the first module")
self.assertIs(
module_A,
ipopo.get_factory_bundle(module_B.BASIC_FACTORY).get_module(),
"Duplicated factory is not provided by the first module")
# Component of module A must be there
self.assertIsNotNone(
ipopo.get_instance_details(module_A.BASIC_INSTANCE),
"Component from module A not started")
# Component of module B must be absent
self.assertRaises(ValueError, ipopo.get_instance_details,
module_B.BASIC_INSTANCE)
def setUp(self):
"""
Called before each test. Initiates a framework.
"""
self.framework = FrameworkFactory.get_framework()
self.framework.start()
self.context = self.framework.get_bundle_context()
def setUp(self):
"""
Called before each test. Initiates a framework.
"""
self.framework = FrameworkFactory.get_framework()
self.framework.start()
self.context = self.framework.get_bundle_context()
def setUp(self):
"""
Called before each test. Initiates a framework.
"""
self.framework = FrameworkFactory.get_framework()
self.framework.start()
self.ipopo = install_ipopo(self.framework)
def setUp(self):
"""
Called before each test. Initiates a framework.
"""
self.framework = FrameworkFactory.get_framework()
self.framework.start()
self.ipopo_bundle = install_bundle(self.framework, "pelix.ipopo.core")
def setUp(self):
"""
Called before each test. Initiates a framework.
"""
self.framework = FrameworkFactory.get_framework()
self.framework.start()
self.ipopo = install_ipopo(self.framework)
def testBundleZero(self):
"""
Tests if bundle 0 is the framework
"""
framework = FrameworkFactory.get_framework()
self.assertIsNone(framework.get_bundle_by_name(None),
"None name is not bundle 0")
self.assertIs(framework, framework.get_bundle_by_id(0),
"Invalid bundle 0")
pelix_name = framework.get_symbolic_name()
self.assertIs(framework, framework.get_bundle_by_name(pelix_name),
"Invalid system bundle name")
FrameworkFactory.delete_framework()
def testPropertiesWithoutPreset(self):
"""
Test framework properties
"""
pelix_test_name = "PELIX_TEST"
pelix_test = "42"
# Test without pre-set properties
framework = FrameworkFactory.get_framework()
self.assertIsNone(framework.get_property(pelix_test_name), "Magic property value")
os.environ[pelix_test_name] = pelix_test
self.assertEqual(framework.get_property(pelix_test_name), pelix_test, "Invalid property value")
del os.environ[pelix_test_name]
FrameworkFactory.delete_framework()
def setUp(self):
"""
Called before each test. Initiates a framework and loads the current
module as the first bundle
"""
self.test_bundle_name = "tests.framework.service_bundle"
self.framework = FrameworkFactory.get_framework()
self.framework.start()
def setUp(self):
"""
Called before each test. Initiates a framework.
"""
self.framework = FrameworkFactory.get_framework()
self.framework.start()
self.ipopo = install_ipopo(self.framework)
self.module = install_bundle(self.framework,
"tests.ipopo.ipopo_fields_bundle")
def setUp(self):
"""
Called before each test. Initiates a framework.
"""
self.framework = FrameworkFactory.get_framework()
self.framework.start()
self.ipopo = install_ipopo(self.framework)
self.module = install_bundle(self.framework,
"tests.ipopo.ipopo_fields_bundle")
def setUp(self):
"""
Called before each test. Initiates a framework and loads the current
module as the first bundle
"""
self.test_bundle_name = "tests.framework.service_bundle"
self.framework = FrameworkFactory.get_framework()
self.framework.start()
def setUp(self):
"""
Called before each test. Initiates a framework.
"""
self.framework = FrameworkFactory.get_framework()
self.framework.start()
self.ipopo = install_ipopo(self.framework)
# Install the test bundle
self.module = install_bundle(self.framework)
def setUp(self):
"""
Called before each test. Initiates a framework.
"""
self.framework = FrameworkFactory.get_framework()
self.framework.start()
# Compatibility issue
if sys.version_info[0] < 3:
self.assertCountEqual = self.assertItemsEqual
def testPropertiesWithoutPreset(self):
"""
Test framework properties
"""
pelix_test_name = "PELIX_TEST"
pelix_test = "42"
# Test without pre-set properties
framework = FrameworkFactory.get_framework()
self.assertIsNone(framework.get_property(pelix_test_name),
"Magic property value")
os.environ[pelix_test_name] = pelix_test
self.assertEqual(framework.get_property(pelix_test_name), pelix_test,
"Invalid property value")
del os.environ[pelix_test_name]
FrameworkFactory.delete_framework()
def setUp(self):
"""
Called before each test. Initiates a framework.
"""
self.framework = FrameworkFactory.get_framework()
self.framework.start()
self.ipopo = install_ipopo(self.framework)
# Install the test bundle
self.module = install_bundle(self.framework)
def setUp(self):
"""
Called before each test. Initiates a framework.
"""
self.framework = FrameworkFactory.get_framework()
self.framework.start()
self.test_bundle_name = SIMPLE_BUNDLE
self.bundle = None
self.received = []
def setUp(self):
"""
Called before each test. Initiates a framework.
"""
self.framework = FrameworkFactory.get_framework()
self.framework.start()
self.context = self.framework.get_bundle_context()
# Get the path to the current test package
self.test_root = os.path.join(
os.path.abspath(os.path.dirname(__file__)), "vault")