class ClassToJsUnitTest(SimpleRpcLogicBase):
'''
#TODO: document
'''
def __post_init__(self):
self.class_to_js = ClassToJs(self.context)
self.templates = TemplatesCollector(self.context)
self.file_manager = FileManager(self.context)
def translateClass(self, class_):
''' '''
ast_tree = self.class_to_js.translateClass(class_)
templates_set = 'js_unittest_templates'
templates = self.templates.collectBuiltIn(templates_set)
js_str = ast_tree.getString(templates)
return js_str
def translateToFile(self, tested_class, file_path, overwrite=False):
js_str = self.__getClassJsUnit(tested_class)
#create directory just in case
test_dir = os.path.dirname(file_path)
self.file_manager.makedirs(test_dir)
#Say where it is in a pretty way
path = self.file_manager.formatFilePath(file_path)
name = tested_class.__name__
self.log.d('Creating js for %s test at:\n %s' % (name, path))
#save file
self.file_manager.saveTextFile(file_path, js_str, overwrite)
def __getClassJsUnit(self, tested_class):
js_str = self.translateClass(tested_class)
translate = dict(EXPOSED_RPC_API_CLASS=self.context.js_rpc_file)
js_str = Template(js_str).safe_substitute(translate)
return js_str
class ModuleUnitTestRunner(SimpleRpcLogicBase):
def __post_init__(self):
self.twins_manager = TwinModulesManager(self.context)
self.file_manager = FileManager(self.context)
self.nodejs = NodeJsRunner(self.context)
def runTestByNumber(self, package, test_number):
tests_dict = self._getTestDict()
sorted_names = self.__getSortedNames(tests_dict)
new_dict = dict((module.__name__, class_) for module, class_ in tests_dict.items())
tester_class = new_dict[sorted_names[test_number]]
self.runPythonTest(tester_class)
def __runUnitTest(self, tester_class):
tester_class.setTestsContext(self.context)
suite = TestLoader().loadTestsFromTestCase(tester_class)
TextTestRunner().run(suite)
def runPythonTest(self, tested_class):
tester_class = self.twins_manager.getTesterFromTested(tested_class)
path = self.file_manager.formatClassFilePath(tester_class)
name = tester_class.__name__
self.log.d('Running %r test at:\n %s' % (name, path))
#self.module_unit_test_runner.runPythonTest(tester_class)
self.__runUnitTest(tester_class)
def runJsTest(self, tested_class):
file_path = self.twins_manager.getJsUnittest(tested_class)
path = self.file_manager.formatFilePath(file_path)
self.log.d('Running jasmine test at:\n%s' % path)
ret_val = self.nodejs.runJasmineTest(file_path)
if ret_val:
raise SimpleRpcError('Jasmine test failed')
class TemplatesCollector(SimpleRpcLogicBase):
'''
Collects templates into stores in the repository
to be used in the translation by the TranslationAstNode class.
'''
def __post_init__(self):
self.file_manager = FileManager(self.context)
def _getRepoPath(self, templates_set):
return joinPath(os.path.dirname(__file__), templates_set)
def _getTemplatesPaths(self, pattern, templates_set):
for root, _, files in os.walk(self._getRepoPath(templates_set),
followlinks=True):
for basename in files:
if fnmatch.fnmatch(basename, pattern):
filename = os.path.join(root, basename)
yield filename
def _buildNamespace(self, file_path, templates_set):
repo_split = splitPath(self._getRepoPath(templates_set))
namespace, _ = os.path.splitext(file_path)
namespace = splitPath(namespace)[len(repo_split):]
return '.'.join(namespace)
def collectBuiltIn(self, templates_set='javascript_templates'):
templates = dict()
for file_path in self._getTemplatesPaths('*.js', templates_set):
namespace = self._buildNamespace(file_path, templates_set)
template = self.file_manager.getTextFile(file_path)
templates[namespace] = template
return templates
class ExposedTestBase(SimpleRpcLogicBase):
tests_context = None
@staticmethod
def setTestsContext(context):
ExposedTestBase.tests_context = context
def __init__(self, first_arg=None):
#Initialize the class if inheriting from TestCase
if isinstance(self, TestCase): #If using unittest, then initialize the class
#Keep signature
if isinstance(first_arg, str):
methodName = first_arg
first_arg = None
TestCase.__init__(self, methodName)
else:
TestCase.__init__(self)
context = first_arg
#Solve context if not provided
if context == None:
if ExposedTestBase.tests_context == None: #To enable context free initialization supporting unittest.TestCase
self.__runs_from_tested_module = False
ExposedTestBase.tests_context = SimpleRpcContext(self.__class__.__name__)
else:
self.__runs_from_tested_module = True
context = ExposedTestBase.tests_context
SimpleRpcLogicBase.__init__(self, context)
def __post_init__(self):
self.twins_manager = TwinModulesManager(self.context)
self.module_unit_test_runner = ModuleUnitTestRunner(self.context)
self.file_manager = FileManager(self.context)
def runTest(self):
pass
def __printTestedClassFile(self, tested_class):
path = self.file_manager.formatClassFilePath(tested_class)
name = tested_class.__name__
self.log.d('Testing %r at:\n %s' % (name, path))
def testJsJasmine(self):
tested_class = self._getTestedClass()
self.module_unit_test_runner.runJsTest(tested_class)
def testMethodsExistence(self):
tested_class = self._getTestedClass()
if not self.__runs_from_tested_module:
self.__printTestedClassFile(tested_class)
#tested_instance =
for name, attrib in tested_class.__dict__.items():
if callable(attrib) and not name.startswith('_'):
test_name = 'test_%s' % name
msg = 'There is no test test_%s for class %r' % (name, tested_class)
assert test_name in self.__class__.__dict__, msg
#assert callable(self.__class__.__dict__[test_name]) #TODO: necessary?
def _getTestedClass(self):
return self.twins_manager.getTestedFromTester(self.__class__)
class RPCJavascriptGenerator(SimpleRpcLogicBase):
def __post_init__(self):
self.file_manager = FileManager(self.context)
self.package_translator = PackageToJs(self.context)
self.templates_collector = TemplatesCollector(self.context)
self.js_util = JsTranslateUtil(self.context)
def getRpcNode(self, packages):
packages_node = AutoTemplateAstNode()
for p in packages:
n = self.package_translator.translatePackage(p)
name = p.__name__.split('.')[-1]
packages_node.translate(name, n)
exposed_rpc_node = TranslationAstNode('exposed_rpc.CommandQueueApi')
exposed_rpc_node.translate(EXPOSED_PACKAGES=packages_node)
return exposed_rpc_node
def translateToFile(self, packages, js_rpc_file=None, templates=None,
overwrite=False):
js_rpc_file = self.js_util._getJsRpcFile(js_rpc_file)
if not templates:
templates = self.templates_collector.collectBuiltIn()
text = self.getRpcNode(packages).getString(templates)
self.file_manager.saveTextFile(js_rpc_file, text, overwrite)
class NodeJsRunner(SimpleRpcLogicBase):
def __post_init__(self):
self.js_util = JsTranslateUtil(self.context)
self.file_manager = FileManager(self.context)
def setNodePath(self):
NODE_PATH = 'NODE_PATH'
path = self.js_util._getProjectJsPath()
if NODE_PATH not in os.environ:
os.environ[NODE_PATH] = path
else:
os.environ[NODE_PATH] += ':' + path
def __printJasmineErrors(self, file_path, ret_val, out, err):
if ret_val:
path = self.file_manager.formatFilePath(file_path)
self.log.w('Error running jasmine test return value %s:\n%s' %
(ret_val, path))
self.log.w('Stdout:\n%s' % out)
self.log.w('Stderr:\%s' % err)
return ret_val
def runJasmineTest(self, file_path):
argv = [self.context.jasmine_node_command, file_path, '--matchall',
'--captureExceptions', '--noColor']
return self.__printJasmineErrors(file_path, *self.__runProcess(argv,
pipe=True))
def __runProcess(self, argv, pipe):
#we need to know where the .js are
self.setNodePath()
#run the process!
if pipe:
p = subprocess.Popen(argv, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
return p.wait(), p.stdout.read(), p.stderr.read()
else:
p = subprocess.Popen(argv)
return p.wait()
def runNodeJs(self, argv=None, pipe=False):
#node_command = 'node'
if not argv:
argv = sys.argv[1:]
argv = [self.context.node_command] + argv
return self.__runProcess(argv, pipe)
def __post_init__(self):
self.file_manager = FileManager(self.context)
def __post_init__(self):
self.twins_manager = TwinModulesManager(self.context)
self.file_manager = FileManager(self.context)
self.nodejs = NodeJsRunner(self.context)
def __post_init__(self):
self.file_manager = FileManager(self.context)
self.package_translator = PackageToJs(self.context)
self.templates_collector = TemplatesCollector(self.context)
self.js_util = JsTranslateUtil(self.context)
def __post_init__(self):
self.twins_manager = TwinModulesManager(self.context)
self.module_unit_test_runner = ModuleUnitTestRunner(self.context)
self.file_manager = FileManager(self.context)
def __post_init__(self):
self.js_util = JsTranslateUtil(self.context)
self.file_manager = FileManager(self.context)
def __post_init__(self):
self.class_to_js = ClassToJs(self.context)
self.templates = TemplatesCollector(self.context)
self.file_manager = FileManager(self.context)
