def test_create(): """Test creating an authority. """ def _test(func, typeof): """Inner test. """ node = func() tu.assert_object(node, typeof) assert node == load(node.namespace) for factory, typeof in ( (tu.create_authority, LIB.Authority), (tu.create_scope, LIB.Scope), (tu.create_collection_01, LIB.Collection), (tu.create_collection_02, LIB.Collection), (tu.create_collection_03, LIB.Collection), (tu.create_term_01, LIB.Term), (tu.create_term_02, LIB.Term), (tu.create_term_03, LIB.Term) ): tu.init(_test, 'create --> {}'.format(factory.__name__[7:])) yield _test, factory, typeof
def test_encode(): """pyessv-tests: encode. """ def _test(node, encoding): """Inner test. """ representation = encode(node, encoding) assert isinstance(representation, _ENCODING_REPRESENTATION_TYPE[encoding]) decoded = decode(representation, encoding) assert isinstance(decoded, type(node)) for field in STANDARD_NODE_FIELDS: assert getattr(decoded, field) == getattr(node, field) for node_factory in (tu.create_authority, tu.create_scope, tu.create_collection_01, tu.create_collection_02, tu.create_collection_03, tu.create_term_01, tu.create_term_02, tu.create_term_03): node = node_factory() for encoding in ENCODING_SET: desc = 'codecs: {} --> {}'.format(node_factory.__name__[7:], encoding) tu.init(_test, desc) yield _test, node, encoding
def test_parse_identifiers(): """pyessv-tests: parsing: identifiers """ def positive_test(parser, project, identifier): parser(project, identifier) @nose.tools.raises(LIB.TemplateParsingError) def negative_test(parser, project, identifier): parser(project, identifier) # Iterate identifiers & perform +ve / -ve tests: for project, parser, seperator, identifiers in _CONFIG: assert inspect.isfunction(parser) for identifier in identifiers: # ... +ve test: desc = 'identifier parsing test (+ve) --> {} :: {}'.format( project, identifier) tu.init(positive_test, desc) yield positive_test, parser, project, identifier # ... -ve tests: for invalid_identifier in _get_invalid_identifiers( identifier, seperator): desc = 'identifier parsing test (-ve) --> {} :: {}'.format( project, invalid_identifier) tu.init(negative_test, desc) yield negative_test, parser, project, invalid_identifier
def test_iterability(): """Test iterability of domain model. """ def _test(node, keys): """Inner test. """ assert iter(node) assert len(node) == len(keys) for key in keys: assert key in node assert node[key] is not None for node_factory, keys in ( (tu.create_authority, [tum.SCOPE_NAME]), (tu.create_scope, [ tum.COLLECTION_01_NAME, tum.COLLECTION_02_NAME, tum.COLLECTION_03_NAME ]), (tu.create_collection_01, [tum.TERM_01_NAME]), (tu.create_collection_02, [tum.TERM_02_NAME]), (tu.create_collection_03, [tum.TERM_03_NAME]), ): desc = 'iterate --> {}'.format(node_factory.__name__[7:]) tu.init(_test, desc) yield _test, node_factory(), keys
def test_parse_name(): """Test parsing of names at various levels. """ for typekey, canonical_name, alternative_names, parent in _INPUTS: for alternative_name in alternative_names: for name, expected, strictness in _get_config( canonical_name, alternative_name): desc = 'parse --> {}: {} [strictness={}]'.format( typekey, name, strictness) tu.init(_test_parse_name, desc) yield _test_parse_name, typekey, name, expected, strictness, parent
def test(): """pyessv-tests: governance: accept term """ for func, status, desc in ( (pyessv.accept, pyessv.GOVERNANCE_STATUS_ACCEPTED, 'accept'), # (pyessv.reject, pyessv.GOVERNANCE_STATUS_REJECTED, 'reject'), # (pyessv.reset, pyessv.GOVERNANCE_STATUS_PENDING, 'reset'), # (pyessv.deprecate, pyessv.GOVERNANCE_STATUS_DEPRECATED, 'deprecate') ): tu.init(_test, 'governance', '{} term'.format(desc)) yield _test, func, status
def test_node(): """Tests node validation. """ for node_factory in (tu.create_authority, tu.create_scope, tu.create_collection_01, tu.create_collection_02, tu.create_collection_03, tu.create_term_01, tu.create_term_02, tu.create_term_03): node = node_factory() for attr, invalid in _TEST_INFO[type(node)]: tu.init( _test_node_attr, 'validate --> {}: {}'.format(node_factory.__name__[7:], attr)) yield _test_node_attr, node, attr, invalid
def test(): """pyessv-tests: governance: accept term """ for func, status, desc in ( (pyessv.accept, pyessv.GOVERNANCE_STATUS_ACCEPTED, "accept"), # (pyessv.reject, pyessv.GOVERNANCE_STATUS_REJECTED, "reject"), # (pyessv.reset, pyessv.GOVERNANCE_STATUS_PENDING, "reset"), # (pyessv.deprecate, pyessv.GOVERNANCE_STATUS_DEPRECATED, "deprecate") ): tu.init(_test, 'governance', "{} term".format(desc)) yield _test, func, status
def test_expressions(): """pyessv-tests: expression: valid. """ def _do_positive_test(template, parser): parser.parse(_VALID[template]) @nose.tools.raises(ValueError) def _do_negative_test(template, parser): parser.parse(_INVALID[template]) _setup() for template in _TEMPLATES: tu.init(_do_positive_test, 'parse expression (+ve) :: {}'.format(template)) yield _do_positive_test, template, _PARSERS[template] tu.init(_do_negative_test, 'parse expression (-ve) :: {}'.format(template)) yield _do_negative_test, template, _PARSERS[template]
def test_create(): """Test creating a term. """ @nose.with_setup(tu.setup, tu.teardown) def test_create_01(): """Create term.""" term = tu.create_term() tu.assert_object(term, pyessv.Term) tu.assert_int(pyessv.get_count(), 0) @nose.with_setup(_setup, tu.teardown) def test_create_02(): """Create & save term.""" term = pyessv.get_term(tu.TERM_DOMAIN, tu.TERM_SUBDOMAIN, tu.TERM_KIND, tu.TERM_NAME) tu.assert_object(term, pyessv.Term) for test in (test_create_01, test_create_02): tu.init(test, 'authoring', inspect.getdoc(test)) yield test
def test_library_exports(): """Test set of exports exposed by library. """ def _test_member(member, member_type): """Test that library exposes the named member. """ assertor = getattr(tu, 'assert_has_{}'.format(member_type)) assertor(LIB, member) for members, member_type, in ( (_CLASSES, 'class'), (_CONSTANTS, 'constant'), (_EXCEPTIONS, 'exception'), (_FUNCS, 'function'), ): for member in sorted(members): desc = 'library exposes {} --> {}'.format(member_type, member) tu.init(_test_member, desc) yield _test_member, member, member_type
def test_update(): """Test updating a term. """ def _update_create_date(term): """Update term create date.""" term.create_date = tu.get_date() def _update_description(term): """Update term description.""" term.description = tu.get_uuid() def _update_domain(term): """Update term domain.""" term.domain = tu.get_unicode(existing=term.domain) def _update_id(term): """Update term id.""" term.idx = tu.get_int(existing=term.idx) def _update_kind(term): """Update term kind.""" term.kind = tu.get_unicode(existing=term.kind) def _update_name(term): """Update term name.""" term.name = tu.get_unicode(existing=term.name) def _update_status(term): """Update term status.""" term.status = tu.get_unicode(existing=term.status) def _update_subdomain(term): """Update term subdomain.""" term.subdomain = tu.get_unicode(existing=term.subdomain) def _update_uid(term): """Update term uid.""" term.uid = tu.get_uuid() def _assert(term): """Asserts an update.""" count = pyessv.get_count() pyessv.save(term) tu.assert_int(pyessv.get_count(), count) term_ = pyessv.get_term(term.domain, term.subdomain, term.kind, term.name) tu.assert_terms(term, term_) @nose.with_setup(_setup, tu.teardown) def _test(update_callback): """Performs update test.""" term = tu.get_term() update_callback(term) _assert(term) for func in ( _update_create_date, _update_description, _update_domain, _update_id, _update_kind, _update_name, _update_status, _update_subdomain, _update_uid ): tu.init(_test, 'authoring', inspect.getdoc(func)) yield _test, func