def get_metadata(opts):
"""
return a list of metadata objects that we would like to
run test for. If buildbot option is set then we read
from the config file, otherwise we return the current
IDK driver metadata
@param opts: command line options dictionary.
@return: list of all metadata data objects we would
like to run tests for.
"""
result = []
if (opts.buildbot):
devices = read_buildbot_config()
ret = True
for (key, config) in devices:
make = config.get(BuildBotConfig.MAKE)
model = config.get(BuildBotConfig.MODEL)
flavor = config.get(BuildBotConfig.FLAVOR)
metadata = Metadata(make, model, flavor)
result.append(metadata)
pass
else:
result.append(Metadata())
return result
def get_metadata(self):
# get which dataset agent is selected from the current metadata, use
# this to get metadata from the cloned repo
tmp_metadata = Metadata()
# read metadata from the cloned repo
self.metadata = Metadata(tmp_metadata.driver_make,
tmp_metadata.driver_model,
tmp_metadata.driver_name,
REPODIR + '/marine-integrations')
return self.metadata
def test_constructor(self):
"""
Test object creation
"""
default_metadata = Metadata()
self.assertTrue(default_metadata)
specific_metadata = Metadata('seabird', 'sbe37smb', 'ooicore')
self.assertTrue(specific_metadata)
failure_metadata = None
try:
failure_metadata = Metadata('seabird')
except InvalidParameters, e:
self.assertTrue(e)
def test_list(self):
"""
Test the full file manifest
"""
filelist = DriverFileList(Metadata(), ROOTDIR, self.implfile(), self.nosefile())
self.assertTrue(filelist)
known_files = [
'mi/__init__.py',
'mi/base.py',
'mi/base2.py',
'mi/base3.py',
'mi/base4.py',
'mi/foo/__init__.py',
'mi/foo/impl.py',
'mi/foo/res/test_file',
'mi/foo/test/__init__.py',
'mi/foo/test/test_process.py',
'res/config/mi-logging.yml'
]
files = filelist.files()
#log.debug( "F: %s" % files)
self.assertEqual(sorted(files), sorted(known_files))
def test_sbe37_list(self):
metadata = Metadata('seabird', 'sbe37smb', 'ooicore')
filelist = DriverFileList(metadata, Config().get('working_repo'))
known_files = [
'mi/instrument/seabird/sbe37smb/ooicore/comm_config.yml',
'mi/instrument/seabird/sbe37smb/ooicore/metadata.yml',
'mi/__init__.py', 'mi/core/__init__.py', 'mi/core/common.py',
'mi/core/exceptions.py', 'mi/core/instrument/__init__.py',
'mi/core/instrument/data_particle.py',
'mi/core/instrument/instrument_driver.py',
'mi/core/instrument/instrument_fsm.py',
'mi/core/instrument/instrument_protocol.py',
'mi/core/instrument/protocol_param_dict.py',
'mi/instrument/__init__.py', 'mi/instrument/seabird/__init__.py',
'mi/instrument/seabird/sbe37smb/__init__.py',
'mi/instrument/seabird/sbe37smb/ooicore/__init__.py',
'mi/instrument/seabird/sbe37smb/ooicore/driver.py',
'mi/core/instrument/driver_client.py',
'mi/core/instrument/driver_process.py',
'mi/core/instrument/zmq_driver_client.py',
'mi/core/instrument/zmq_driver_process.py', 'mi/idk/__init__.py',
'mi/idk/comm_config.py', 'mi/idk/common.py', 'mi/idk/config.py',
'mi/idk/exceptions.py', 'mi/idk/prompt.py', 'mi/core/log.py',
'mi/core/tcp_client.py', 'mi/core/unit_test.py', 'mi/idk/util.py',
'mi/idk/instrument_agent_client.py',
'mi/core/instrument/port_agent_client.py',
'mi/core/instrument/logger_client.py', 'mi/idk/unit_test.py',
'mi/instrument/seabird/sbe37smb/ooicore/test/__init__.py',
'mi/instrument/seabird/sbe37smb/ooicore/test/test_driver.py'
]
self.maxDiff = None
files = filelist.files()
log.debug("FILES = " + str(sorted(files)))
self.assertEqual(sorted(files), sorted(known_files))
def overwrite(self):
"""
@brief Overwrite the current files with what is stored in the current metadata file.
"""
self.metadata = Metadata()
config_path = "%s/%s" % (self.metadata.driver_dir(), CommConfig.config_filename())
self.comm_config = CommConfig.get_config_from_file(config_path)
self.generate_code(force = True)
def setUp(self):
"""
Setup the test case
"""
metadata = Metadata(TEST_DRIVER_MAKE, TEST_DRIVER_MODEL,
TEST_DRIVER_FLAVOR)
self.assertTrue(metadata)
self.nose = NoseTest(metadata)
self.assertTrue(self.nose)
def run(self):
print "*** Starting Driver Packaging Process***"
# store the original directory since we will be navigating away from it
original_dir = os.getcwd()
# first create a temporary clone of ooici to work with
self.clone_repo()
# get which dataset agent is selected from the current metadata, use
# this to get metadata from the cloned repo
tmp_metadata = Metadata()
# read metadata from the cloned repo
self.metadata = Metadata(tmp_metadata.driver_make,
tmp_metadata.driver_model,
tmp_metadata.driver_name,
REPODIR + '/marine-integrations')
if "--repackage" in sys.argv:
self.get_repackage_version(self.build_name())
else:
new_version = self.update_version()
base_name = self.build_name() + '_' + new_version.replace('.', '_')
self.make_branch(base_name)
if "--no-test" in sys.argv:
f = open(self.log_path(), "w")
f.write("Tests manually bypassed with --no-test option\n")
f.close()
self.package_driver()
else:
if (self.run_qualification_tests()):
self.package_driver()
if not "--no-push" in sys.argv and not "--repackage" in sys.argv:
cmd = 'git push'
output = subprocess.check_output(cmd, shell=True)
if len(output) > 0:
log.debug('git push returned: %s', output)
# go back to the original directory
os.chdir(original_dir)
print "Package Created: " + self.archive_path()
def fetch_metadata(self):
"""
@brief collect metadata from the user
"""
self.metadata = Metadata()
self.driver_make = self.metadata.driver_make
self.driver_model = self.metadata.driver_model
self.driver_name = self.metadata.driver_name
if not (self.driver_make and self.driver_model and self.driver_name):
self.driver_make = prompt.text('Driver Make', self.driver_make)
self.driver_model = prompt.text('Driver Model', self.driver_model)
self.driver_name = prompt.text('Driver Name', self.driver_name)
if not (self.driver_class):
self.driver_class = prompt.text('Driver Class', self.driver_class)
self.metadata = Metadata(self.driver_make, self.driver_model,
self.driver_name)
def fetch_metadata(self):
"""
@brief collect metadata from the user
"""
if not (self.driver_make and self.driver_model and self.driver_name):
self.driver_make = prompt.text('Driver Make', self.driver_make)
self.driver_model = prompt.text('Driver Model', self.driver_model)
self.driver_name = prompt.text('Driver Name', self.driver_name)
self.metadata = Metadata(self.driver_make, self.driver_model,
self.driver_name)
self.driver_version = prompt.text('Driver Version',
self.metadata.version)
def setUp(self):
IDKPackageNose.setUp(self)
self._metadata = Metadata('seabird', 'sbe37smb', 'ooicore')
self._generator = EggGenerator(self._metadata)
# Ensure the base build dir doesnt exists
build_dir = path.join(self._generator._tmp_dir(), self._generator._build_name())
if exists(build_dir):
rmtree(build_dir)
self._generator._generate_build_dir()
self._repo_dir = Config().get('working_repo')
self._tmp_dir = Config().get('tmp_dir')
def test_extra_list(self):
"""
Find all the files in the driver directory
"""
rootdir = dirname(TESTDIR)
filelist = DriverFileList(Metadata(), ROOTDIR, self.implfile(), self.nosefile())
self.assertTrue(filelist)
known_files = [
'%s/res/test_file' % TESTDIR
]
files = filelist._extra_files()
#log.debug(sorted(files))
#log.debug(sorted(known_files))
self.assertEqual(sorted(files), sorted(known_files))
def _get_file():
"""
build the data file name. Then loop until the file can be open successfully
@return: file pointer to the data file
"""
metadata = Metadata()
config_path = "%s/%s" % (metadata.driver_dir(), CommConfig.config_filename())
comm_config = CommConfig.get_config_from_file(config_path)
date = time.strftime("%Y%m%d")
filename = "%s/port_agent_%d.%s.data" % (DATADIR, comm_config.command_port, date)
file = None
while(not file):
try:
file = open(filename)
except Exception as e:
sys.stderr.write("file open failed: %s\n" % e)
time.sleep(SLEEP)
return file
def checkout_version(self):
"""
@brief Check out this driver version from the repository if it exists
"""
base_name = '%s_%s_%s_%s' % (self.driver_make, self.driver_model,
self.driver_name,
self.driver_version.replace('.', '_'))
cmd = 'git tag -l ' + 'release_' + base_name
output = subprocess.check_output(cmd, shell=True)
if len(output) > 0:
# this tag exists, check out the branch
#(tag is the branch name with 'release_' in front)
# checkout the branch so changes can be saved
cmd = 'git checkout ' + base_name
output = subprocess.check_output(cmd, shell=True)
# re-read metadata file since it has changed
self.metadata = Metadata(self.driver_make, self.driver_model,
self.driver_name)
else:
raise DriverDoesNotExist("Driver version %s does not exist",
self.driver_version)
def test_nose_with_testname(self):
'''
Test nose when specifying a specific test name
'''
metadata = Metadata(TEST_DRIVER_MAKE, TEST_DRIVER_MODEL,
TEST_DRIVER_FLAVOR)
self.assertTrue(metadata)
self.nose = NoseTest(metadata, testname='test_autosample')
self.assertTrue(self.nose)
# Verify we can get the test module name and file
self.assertEqual(self.nose._driver_test_module(), DRIVER_TEST_MODULE)
test_file = self.nose._driver_test_module().replace('.', '/') + ".py"
self.assertTrue(test_file in self.nose._driver_test_filename())
self.assertEqual(self.nose._unit_test_class, 'SBEUnitTestCase')
self.assertEqual(self.nose._int_test_class, 'SBEIntTestCase')
self.assertEqual(self.nose._qual_test_class,
'SBEQualificationTestCase')
self.assertEqual(self.nose._testname, 'test_autosample')
self.assertEqual(
self.nose._unit_test_module_param(),
"%s:%s.%s" % (self.nose._driver_test_filename(),
self.nose._unit_test_class, 'test_autosample'))
self.assertEqual(
self.nose._int_test_module_param(),
"%s:%s.%s" % (self.nose._driver_test_filename(),
self.nose._int_test_class, 'test_autosample'))
self.assertEqual(
self.nose._qual_test_module_param(),
"%s:%s.%s" % (self.nose._driver_test_filename(),
self.nose._qual_test_class, 'test_autosample'))
def _store_package_files(self):
"""
@brief Store all files in zip archive and add them to the manifest file
"""
# make sure metadata is up to date
self.metadata = Metadata(self.metadata.driver_make,
self.metadata.driver_model,
self.metadata.driver_name,
REPODIR + '/marine-integrations')
self.generator = DriverGenerator(self.metadata)
egg_generator = EggGenerator(self.metadata)
egg_file = egg_generator.save()
# Add egg
self._add_file(egg_file, 'egg', 'python driver egg package')
# Add the package metadata file
self._add_file(self.metadata.metadata_path(),
description='package metadata')
# Add the qualification test log
self._add_file(self.log_path(),
description='qualification tests results')
# Store parameter/command string description file
str_path = "%s/%s" % (self.generator.resource_dir(),
self.string_file())
if os.path.exists(str_path):
self._add_file(str_path, 'resource', 'driver string file')
# Store additional resource files
self._store_resource_files()
# Finally save the manifest file. This must be last of course
self._add_file(self.manifest().manifest_path(),
description='package manifest file')
def fetch_metadata(self):
"""
@brief collect metadata from the user
"""
self.metadata = Metadata()
self.metadata.get_from_console()
def get_metadata(self):
self.metadata = Metadata(self.driver_make, self.driver_model, self.driver_name)
return self.metadata
except IOError as e:
print "Encountered problem writing strings template, complete by hand"
def display_report(self):
"""
@brief Display a report of the files created to STDOUT
"""
print("*** Generation Complete ***")
print(" - Driver File: " + self.driver_dir() + "/" +
self.driver_filename())
print(" - Test File: " + self.driver_test_dir() + "/" +
self.driver_test_filename())
print(" - Resource Directory: " + self.resource_dir())
def generate(self):
"""
@brief Main method for generating drivers. Assumption: this is run from the console.
"""
print("*** Generating Driver Code ***")
self.build_directories()
self.generate_code()
self.display_report()
if __name__ == '__main__':
metadata = Metadata()
driver = DriverGenerator(metadata)
driver.generate()
def fetch_metadata(self):
"""
@brief collect metadata from the user
"""
self.metadata = Metadata()
