class TestBaseCase(unittest.TestCase): """Defines common setup and teardown methods on add unit tests""" def setUp(self): if not hasattr(sys.stdout, 'getvalue') and not hasattr(sys.stderr, 'getvalue'): self.fail('This test needs to be run in buffered mode') # Create a connection to check the contents of the registry self.db = Database(DB_USER, DB_PASSWORD, DB_NAME, DB_HOST, DB_PORT) self.db.clear() self._load_test_dataset() # Create command self.kwargs = {'user' : DB_USER, 'password' : DB_PASSWORD, 'database' :DB_NAME, 'host' : DB_HOST, 'port' : DB_PORT} self.cmd = Remove(**self.kwargs) def tearDown(self): self.db.clear() def _load_test_dataset(self): api.add_unique_identity(self.db, 'FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF') api.add_identity(self.db, 'scm', '*****@*****.**', 'John Smith', uuid='FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF') api.add_identity(self.db, 'scm', '*****@*****.**', 'John Smith', 'jsmith', uuid='FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF') api.add_identity(self.db, 'scm', '*****@*****.**', 'John Doe', 'jdoe')
class TestBaseCase(unittest.TestCase): """Defines common setup and teardown methods on enroll unit tests""" def setUp(self): if not hasattr(sys.stdout, 'getvalue') and not hasattr( sys.stderr, 'getvalue'): self.fail('This test needs to be run in buffered mode') # Create a connection to check the contents of the registry self.db = Database(DB_USER, DB_PASSWORD, DB_NAME, DB_HOST, DB_PORT) # Import predefined dataset for testing self._load_test_dataset() # Create command self.kwargs = { 'user': DB_USER, 'password': DB_PASSWORD, 'database': DB_NAME, 'host': DB_HOST, 'port': DB_PORT } self.cmd = Enroll(**self.kwargs) def tearDown(self): self.db.clear() def _load_test_dataset(self): api.add_unique_identity(self.db, 'John Smith') api.add_unique_identity(self.db, 'John Doe') api.add_organization(self.db, 'Example') api.add_organization(self.db, 'Bitergia')
class TestBaseCase(unittest.TestCase): """Defines common setup and teardown methods on countries unit tests""" def setUp(self): if not hasattr(sys.stdout, 'getvalue') and not hasattr(sys.stderr, 'getvalue'): self.fail('This test needs to be run in buffered mode') self.db = Database(DB_USER, DB_PASSWORD, DB_NAME, DB_HOST, DB_PORT) self._load_test_dataset() # Create command self.kwargs = {'user' : DB_USER, 'password' : DB_PASSWORD, 'database' : DB_NAME, 'host' : DB_HOST, 'port' : DB_PORT} self.cmd = Countries(**self.kwargs) def tearDown(self): self.db.clear() def _load_test_dataset(self): with self.db.connect() as session: us = Country(code='US', name='United States of America', alpha3='USA') es = Country(code='ES', name='Spain', alpha3='ESP') gb = Country(code='GB', name='United Kingdom', alpha3='GBR') session.add(es) session.add(us) session.add(gb)
class TestBaseCase(unittest.TestCase): """Defines common setup and teardown methods on countries unit tests""" def setUp(self): if not hasattr(sys.stdout, 'getvalue') and not hasattr( sys.stderr, 'getvalue'): self.fail('This test needs to be run in buffered mode') self.db = Database(DB_USER, DB_PASSWORD, DB_NAME, DB_HOST, DB_PORT) self._load_test_dataset() # Create command self.kwargs = { 'user': DB_USER, 'password': DB_PASSWORD, 'database': DB_NAME, 'host': DB_HOST, 'port': DB_PORT } self.cmd = Countries(**self.kwargs) def tearDown(self): self.db.clear() def _load_test_dataset(self): with self.db.connect() as session: us = Country(code='US', name='United States of America', alpha3='USA') es = Country(code='ES', name='Spain', alpha3='ESP') gb = Country(code='GB', name='United Kingdom', alpha3='GBR') session.add(es) session.add(us) session.add(gb)
class TestBaseCase(unittest.TestCase): """Defines common setup and teardown methods on profile unit tests""" def setUp(self): if not hasattr(sys.stdout, 'getvalue'): self.fail('This test needs to be run in buffered mode') # Create a connection to check the contents of the registry self.db = Database(DB_USER, DB_PASSWORD, DB_NAME, DB_HOST, DB_PORT) # Import predefined dataset for testing self._load_test_dataset() # Create command self.kwargs = {'user' : DB_USER, 'password' : DB_PASSWORD, 'database' :DB_NAME, 'host' : DB_HOST, 'port' : DB_PORT} self.cmd = Profile(**self.kwargs) def tearDown(self): self.db.clear() def _load_test_dataset(self): # Add country with self.db.connect() as session: # Add a country us = Country(code='US', name='United States of America', alpha3='USA') session.add(us) # Add identity api.add_identity(self.db, 'scm', '*****@*****.**', 'Jane Roe', 'jroe')
class TestBaseCase(unittest.TestCase): """Defines common setup and teardown methods on enroll unit tests""" def setUp(self): if not hasattr(sys.stdout, 'getvalue') and not hasattr(sys.stderr, 'getvalue'): self.fail('This test needs to be run in buffered mode') # Create a connection to check the contents of the registry self.db = Database(DB_USER, DB_PASSWORD, DB_NAME, DB_HOST, DB_PORT) # Import predefined dataset for testing self._load_test_dataset() # Create command self.kwargs = {'user' : DB_USER, 'password' : DB_PASSWORD, 'database' :DB_NAME, 'host' : DB_HOST, 'port' : DB_PORT} self.cmd = Enroll(**self.kwargs) def tearDown(self): self.db.clear() def _load_test_dataset(self): api.add_unique_identity(self.db, 'John Smith') api.add_unique_identity(self.db, 'John Doe') api.add_organization(self.db, 'Example') api.add_organization(self.db, 'Bitergia')
class TestBlacklist(unittest.TestCase): def setUp(self): if not hasattr(sys.stdout, 'getvalue'): self.fail('This test needs to be run in buffered mode') self.db = Database(DB_USER, DB_PASSWORD, DB_NAME, DB_HOST, DB_PORT) api.add_to_matching_blacklist(self.db, '*****@*****.**') api.add_to_matching_blacklist(self.db, 'John Smith') api.add_to_matching_blacklist(self.db, 'Bitergia') api.add_to_matching_blacklist(self.db, 'John Doe') # Create command self.kwargs = {'user' : DB_USER, 'password' : DB_PASSWORD, 'database' :DB_NAME, 'host' : DB_HOST, 'port' : DB_PORT} self.cmd = Blacklist(**self.kwargs) def tearDown(self): self.db.clear() def test_blacklist(self): """Check blacklist output list""" code = self.cmd.blacklist() self.assertEqual(code, CMD_SUCCESS) output = sys.stdout.getvalue().strip() self.assertEqual(output, BLACKLIST_OUTPUT) def test_blacklist_term(self): """Check if it returns the info about entries using a search term""" code = self.cmd.blacklist('ohn') self.assertEqual(code, CMD_SUCCESS) output = sys.stdout.getvalue().strip() self.assertEqual(output, BLACKLIST_OUTPUT_JOHN) def test_not_found_term(self): """Check whether it prints an error for not existing entries""" code = self.cmd.blacklist('*****@*****.**') self.assertEqual(code, CODE_NOT_FOUND_ERROR) output = sys.stderr.getvalue().strip() self.assertEqual(output, BLACKLIST_NOT_FOUND_ERROR) def test_empty_blacklist(self): """Check output when the blacklist is empty""" # Delete the contents of the database self.db.clear() code = self.cmd.blacklist() self.assertEqual(code, CMD_SUCCESS) output = sys.stdout.getvalue().strip() self.assertEqual(output, BLACKLIST_EMPTY_OUTPUT)
class TestBaseCase(unittest.TestCase): """Defines common setup and teardown methods on affiliate unit tests""" def setUp(self): if not hasattr(sys.stdout, 'getvalue') and not hasattr(sys.stderr, 'getvalue'): self.fail('This test needs to be run in buffered mode') # Create a connection to check the contents of the registry self.db = Database(DB_USER, DB_PASSWORD, DB_NAME, DB_HOST, DB_PORT) self._load_test_dataset() # Create command self.kwargs = {'user' : DB_USER, 'password' : DB_PASSWORD, 'database' :DB_NAME, 'host' : DB_HOST, 'port' : DB_PORT} self.cmd = Affiliate(**self.kwargs) def tearDown(self): self.db.clear() def _load_test_dataset(self): # Add some domains api.add_organization(self.db, 'Example') api.add_domain(self.db, 'Example', 'example.com', is_top_domain=True) api.add_organization(self.db, 'Example Alt') api.add_domain(self.db, 'Example Alt', 'u.example.com', is_top_domain=True) api.add_domain(self.db, 'Example Alt', 'es.u.example.com') api.add_domain(self.db, 'Example Alt', 'en.u.example.com') api.add_organization(self.db, 'Bitergia') api.add_domain(self.db, 'Bitergia', 'bitergia.com') api.add_domain(self.db, 'Bitergia', 'bitergia.org') api.add_organization(self.db, 'LibreSoft') # Add some unique identities jsmith_uuid = api.add_identity(self.db, 'scm', '*****@*****.**', 'John Smith', 'jsmith') api.add_identity(self.db, 'scm', '*****@*****.**', 'John Smith', uuid=jsmith_uuid) api.add_identity(self.db, 'scm', '*****@*****.**', 'John Smith', 'jsmith', uuid=jsmith_uuid) api.add_enrollment(self.db, jsmith_uuid, 'Bitergia') # Add John Doe identity api.add_identity(self.db, 'unknown', None, 'John Doe', 'jdoe') # Add Jane Rae identity jroe_uuid = api.add_identity(self.db, 'scm', '*****@*****.**', 'Jane Roe', 'jroe') api.add_identity(self.db, 'scm', '*****@*****.**', uuid=jroe_uuid) api.add_identity(self.db, 'unknown', '*****@*****.**', uuid=jroe_uuid)
class TestBaseCase(unittest.TestCase): """Defines common setup and teardown methods on add unit tests""" def setUp(self): if not hasattr(sys.stdout, 'getvalue') and not hasattr(sys.stderr, 'getvalue'): self.fail('This test needs to be run in buffered mode') # Create a connection to check the contents of the registry self.db = Database(DB_USER, DB_PASSWORD, DB_NAME, DB_HOST, DB_PORT) self.db.clear() self._load_test_dataset() # Create command self.kwargs = {'user' : DB_USER, 'password' : DB_PASSWORD, 'database' :DB_NAME, 'host' : DB_HOST, 'port' : DB_PORT} self.cmd = Merge(**self.kwargs) def tearDown(self): self.db.clear() def _load_test_dataset(self): # Add country with self.db.connect() as session: # Add a country us = Country(code='US', name='United States of America', alpha3='USA') session.add(us) api.add_unique_identity(self.db, 'John Smith') api.add_identity(self.db, 'scm', '*****@*****.**', uuid='John Smith') api.add_identity(self.db, 'scm', '*****@*****.**', 'John Smith', uuid='John Smith') api.edit_profile(self.db, 'John Smith', name='John Smith', is_bot=False) api.add_unique_identity(self.db, 'John Doe') api.add_identity(self.db, 'scm', '*****@*****.**', uuid='John Doe') api.edit_profile(self.db, 'John Doe', email='*****@*****.**', is_bot=True, country_code='US') api.add_organization(self.db, 'Example') api.add_enrollment(self.db, 'John Smith', 'Example') api.add_enrollment(self.db, 'John Doe', 'Example') api.add_organization(self.db, 'Bitergia') api.add_enrollment(self.db, 'John Smith', 'Bitergia') api.add_enrollment(self.db, 'John Doe', 'Bitergia', datetime.datetime(1999, 1, 1), datetime.datetime(2000, 1, 1)) api.add_organization(self.db, 'LibreSoft')
class TestBaseCase(unittest.TestCase): """Defines common setup and teardown methods on unify unit tests""" def setUp(self): if not hasattr(sys.stdout, 'getvalue') and not hasattr(sys.stderr, 'getvalue'): self.fail('This test needs to be run in buffered mode') # Create a connection to check the contents of the registry self.db = Database(DB_USER, DB_PASSWORD, DB_NAME, DB_HOST, DB_PORT) self._load_test_dataset() # Create command self.kwargs = {'user' : DB_USER, 'password' : DB_PASSWORD, 'database' :DB_NAME, 'host' : DB_HOST, 'port' : DB_PORT} self.cmd = Unify(**self.kwargs) def tearDown(self): self.db.clear() def _load_test_dataset(self): # Add some unique identities uuid = api.add_identity(self.db, source='scm', email='*****@*****.**', name='John Smith') api.add_identity(self.db, source='scm', name='John Smith', uuid=uuid) api.add_identity(self.db, source='scm', username='******', uuid=uuid) uuid = api.add_identity(self.db, source='alt', name='J. Smith', username='******') api.add_identity(self.db, source='alt', name='John Smith', username='******', uuid=uuid) api.add_identity(self.db, source='alt', email='jsmith', uuid=uuid) uuid = api.add_identity(self.db, source='scm', name='Jane Rae') api.add_identity(self.db, source='mls', email='*****@*****.**', name='Jane Rae Doe', uuid=uuid) uuid = api.add_identity(self.db, source='scm', name='J. Smith', username='******') api.add_identity(self.db, source='scm', username='******', uuid=uuid) api.add_identity(self.db, source='mls', username='******', uuid=uuid) api.add_identity(self.db, source='mls', email='*****@*****.**', name='Smith. J', uuid=uuid) uuid = api.add_identity(self.db, source='mls', email='*****@*****.**', name='Jane Rae Doe') api.add_identity(self.db, source='mls', name='jrae', uuid=uuid) uuid = api.add_identity(self.db, source='scm', name='jrae')
class TestBaseCase(unittest.TestCase): """Defines common setup and teardown methods on show unit tests""" def setUp(self): if not hasattr(sys.stdout, 'getvalue'): self.fail('This test needs to be run in buffered mode') # Create a connection to check the contents of the registry self.db = Database(DB_USER, DB_PASSWORD, DB_NAME, DB_HOST, DB_PORT) self._load_test_dataset() # Create command self.kwargs = { 'user': DB_USER, 'password': DB_PASSWORD, 'database': DB_NAME, 'host': DB_HOST, 'port': DB_PORT } self.cmd = Load(**self.kwargs) def _load_test_dataset(self): # Add country with self.db.connect() as session: # Add a country us = Country(code='US', name='United States of America', alpha3='USA') session.add(us) def tearDown(self): self.db.clear() def get_parser(self, filename): if sys.version_info[0] >= 3: # Python 3 with open(filename, 'r', encoding='UTF-8') as f: content = f.read() else: # Python 2 with open(filename, 'r') as f: content = f.read().decode('UTF-8') return SortingHatParser(content) def sort_identities(self, ids): return sorted(ids, key=lambda x: x.id)
class TestBaseCase(unittest.TestCase): """Defines common setup and teardown methods on show unit tests""" def setUp(self): if not hasattr(sys.stdout, 'getvalue'): self.fail('This test needs to be run in buffered mode') # Create a connection to check the contents of the registry self.db = Database(DB_USER, DB_PASSWORD, DB_NAME, DB_HOST, DB_PORT) self._load_test_dataset() # Create command self.kwargs = {'user' : DB_USER, 'password' : DB_PASSWORD, 'database' : DB_NAME, 'host' : DB_HOST, 'port' : DB_PORT} self.cmd = Load(**self.kwargs) def _load_test_dataset(self): # Add country with self.db.connect() as session: # Add a country us = Country(code='US', name='United States of America', alpha3='USA') session.add(us) def tearDown(self): self.db.clear() def get_parser(self, filename): if sys.version_info[0] >= 3: # Python 3 with open(filename, 'r', encoding='UTF-8') as f: content = f.read() else: # Python 2 with open(filename, 'r') as f: content = f.read().decode('UTF-8') return SortingHatParser(content) def sort_identities(self, ids): return sorted(ids, key=lambda x: x.id)
class TestBaseCase(unittest.TestCase): """Defines common setup and teardown methods on profile unit tests""" def setUp(self): if not hasattr(sys.stdout, 'getvalue'): self.fail('This test needs to be run in buffered mode') # Create a connection to check the contents of the registry self.db = Database(DB_USER, DB_PASSWORD, DB_NAME, DB_HOST, DB_PORT) # Import predefined dataset for testing self._load_test_dataset() # Create command self.kwargs = { 'user': DB_USER, 'password': DB_PASSWORD, 'database': DB_NAME, 'host': DB_HOST, 'port': DB_PORT } self.cmd = Profile(**self.kwargs) def tearDown(self): self.db.clear() def _load_test_dataset(self): # Add country with self.db.connect() as session: # Add a country us = Country(code='US', name='United States of America', alpha3='USA') session.add(us) # Add identity api.add_identity(self.db, 'scm', '*****@*****.**', 'Jane Roe', 'jroe')
class TestOrgsRegistry(unittest.TestCase): def setUp(self): if not hasattr(sys.stdout, 'getvalue'): self.fail('This test needs to be run in buffered mode') # Create a dataset to test the registry self.db = Database(DB_USER, DB_PASSWORD, DB_NAME, DB_HOST, DB_PORT) api.add_organization(self.db, 'Example') api.add_domain(self.db, 'Example', 'example.com') api.add_domain(self.db, 'Example', 'example.org') api.add_domain(self.db, 'Example', 'example.net') api.add_organization(self.db, 'Bitergia') api.add_domain(self.db, 'Bitergia', 'bitergia.net') api.add_domain(self.db, 'Bitergia', 'bitergia.com', is_top_domain=True) api.add_organization(self.db, 'LibreSoft') # Create command self.kwargs = {'user' : DB_USER, 'password' : DB_PASSWORD, 'database' :DB_NAME, 'host' : DB_HOST, 'port' : DB_PORT} self.cmd = Organizations(**self.kwargs) def tearDown(self): self.db.clear() def test_registry(self): """Check registry output list""" code = self.cmd.registry() self.assertEqual(code, CMD_SUCCESS) output = sys.stdout.getvalue().strip() self.assertEqual(output, REGISTRY_OUTPUT) def test_registry_term(self): """Check if it returns the info about orgs using a search term""" # Add an extra organization first api.add_organization(self.db, 'MyExample') api.add_domain(self.db, 'MyExample', 'myexample.com') code = self.cmd.registry('Example') self.assertEqual(code, CMD_SUCCESS) output = sys.stdout.getvalue().strip() self.assertEqual(output, REGISTRY_OUTPUT_EXAMPLE) def test_not_found_term(self): """Check whether it prints an error for not existing organizations""" code = self.cmd.registry('Bitergium') self.assertEqual(code, CODE_NOT_FOUND_ERROR) output = sys.stderr.getvalue().strip() self.assertEqual(output, REGISTRY_ORG_NOT_FOUND_ERROR) def test_empty_registry(self): """Check output when the registry is empty""" # Delete the contents of the database self.db.clear() code = self.cmd.registry() self.assertEqual(code, CMD_SUCCESS) output = sys.stdout.getvalue().strip() self.assertEqual(output, REGISTRY_EMPTY_OUTPUT)
class TestOrgsCommand(unittest.TestCase): """Organization command unit tests""" def setUp(self): if not hasattr(sys.stdout, 'getvalue'): self.fail('This test needs to be run in buffered mode') # Create a connection to check the contents of the registry self.db = Database(DB_USER, DB_PASSWORD, DB_NAME, DB_HOST, DB_PORT) # Create command self.kwargs = {'user' : DB_USER, 'password' : DB_PASSWORD, 'database' :DB_NAME, 'host' : DB_HOST, 'port' : DB_PORT} self.cmd = Organizations(**self.kwargs) def tearDown(self): self.db.clear() def test_default_action(self): """Check whether when no action is given it runs --list""" # Add some contents first self.cmd.add('Example') self.cmd.add('Example', 'example.com') self.cmd.add('Example', 'example.org') self.cmd.add('Example', 'example.net') self.cmd.add('MyExample') self.cmd.add('MyExample', 'myexample.com') code = self.cmd.run() self.assertEqual(code, CMD_SUCCESS) output = sys.stdout.getvalue().strip() self.assertEqual(output, REGISTRY_OUTPUT_EXAMPLE) def test_list_without_args(self): """Test list action with and without arguments""" self.__load_test_dataset() code = self.cmd.run('-l') self.assertEqual(code, CMD_SUCCESS) output = sys.stdout.getvalue().strip() self.assertEqual(output, REGISTRY_OUTPUT) def test_list_with_args(self): """Test list action with arguments""" self.__load_test_dataset() # Add an extra organization self.cmd.add('MyExample') self.cmd.add('MyExample', 'myexample.com') code = self.cmd.run('--list', 'Example') self.assertEqual(code, CMD_SUCCESS) output = sys.stdout.getvalue().strip() self.assertEqual(output, REGISTRY_OUTPUT_EXAMPLE) def test_add_with_args(self): """Test add action""" code = self.cmd.run('--add', 'LibreSoft') self.assertEqual(code, CMD_SUCCESS) code = self.cmd.run('-a', 'Example') self.assertEqual(code, CMD_SUCCESS) code = self.cmd.run('--add', 'Example', 'example.com') self.assertEqual(code, CMD_SUCCESS) code = self.cmd.run('--add', 'Bitergia') self.assertEqual(code, CMD_SUCCESS) code = self.cmd.run('-a', 'Bitergia', 'bitergia.net') self.assertEqual(code, CMD_SUCCESS) code = self.cmd.run('--add', 'Example', 'example.org') self.assertEqual(code, CMD_SUCCESS) code = self.cmd.run('--add', 'Bitergia', 'bitergia.com', '--top-domain') self.assertEqual(code, CMD_SUCCESS) code = self.cmd.run('-a', 'Example', 'example.net') self.assertEqual(code, CMD_SUCCESS) self.cmd.run('--list') output = sys.stdout.getvalue().strip() self.assertEqual(output, REGISTRY_OUTPUT) def test_add_without_args(self): """Check when calling --add without args, it does not do anything""" code = self.cmd.run('--add') self.assertEqual(code, CMD_SUCCESS) self.cmd.run('-l') output = sys.stdout.getvalue().strip() self.assertEqual(output, REGISTRY_EMPTY_OUTPUT) def test_add_with_overwrite_option(self): """Check whether it not fails running add with overwrite option""" self.__load_test_dataset() code = self.cmd.run('--add', 'Example', 'bitergia.com') self.assertEqual(code, CODE_ALREADY_EXISTS_ERROR) output = sys.stderr.getvalue().strip() self.assertEqual(output, REGISTRY_DOM_ALREADY_EXISTS_ERROR) code = self.cmd.run('--add', '--overwrite', 'Example', 'bitergia.com') self.assertEqual(code, CMD_SUCCESS) self.cmd.run('-l') output = sys.stdout.getvalue().strip() self.assertEqual(output, REGISTRY_OUTPUT_ALT) def test_delete_with_args(self): """Test delete action""" self.__load_test_dataset() # Delete contents code = self.cmd.run('--delete', 'Bitergia', 'bitergia.com') self.assertEqual(code, CMD_SUCCESS) code = self.cmd.run('-d', 'LibreSoft') self.assertEqual(code, CMD_SUCCESS) code = self.cmd.run('--delete', 'Bitergia') self.assertEqual(code, CMD_SUCCESS) code = self.cmd.run('-d', 'Example', 'example.org') self.assertEqual(code, CMD_SUCCESS) self.cmd.run('--list') output = sys.stdout.getvalue().strip() self.assertEqual(output, REGISTRY_OUTPUT_EXAMPLE_ALT) def test_delete_without_args(self): """Check when calling --delete without args, it does not do anything""" self.__load_test_dataset() code = self.cmd.run('--delete') self.assertEqual(code, CMD_SUCCESS) self.cmd.run('-l') output = sys.stdout.getvalue().strip() self.assertEqual(output, REGISTRY_OUTPUT) def test_run_mixing_actions(self): """Check how it works when mixing actions""" self.cmd.run('--add', 'LibreSoft') self.cmd.run('-a', 'LibreSoft', 'libresoft.es') self.cmd.run('-a', 'Example') self.cmd.run('--add', 'Example', 'example.org') self.cmd.run('-d', 'Example', 'example.org') self.cmd.run('--add', 'Bitergia') self.cmd.run('-a', 'Bitergia', 'bitergia.net') self.cmd.run('--delete', 'LibreSoft') self.cmd.run('--add', 'Example', 'example.com') self.cmd.run('--add', 'Bitergia', 'bitergia.com') self.cmd.run('-a', 'Example', 'example.net') self.cmd.run('--delete', 'Bitergia', 'bitergia.com') self.cmd.run('-d', 'Bitergia') self.cmd.run() output = sys.stdout.getvalue().strip() self.assertEqual(output, REGISTRY_OUTPUT_EXAMPLE_ALT) def __load_test_dataset(self): self.cmd.add('Example') self.cmd.add('Example', 'example.com') self.cmd.add('Bitergia') self.cmd.add('Bitergia', 'bitergia.net') self.cmd.add('Bitergia', 'bitergia.com', is_top_domain=True) self.cmd.add('LibreSoft') self.cmd.add('Example', 'example.org') self.cmd.add('Example', 'example.net')
class TestOrgsAdd(unittest.TestCase): def setUp(self): if not hasattr(sys.stdout, 'getvalue'): self.fail('This test needs to be run in buffered mode') # Create a connection to check the contents of the registry self.db = Database(DB_USER, DB_PASSWORD, DB_NAME, DB_HOST, DB_PORT) # Create command self.kwargs = {'user' : DB_USER, 'password' : DB_PASSWORD, 'database' :DB_NAME, 'host' : DB_HOST, 'port' : DB_PORT} self.cmd = Organizations(**self.kwargs) def tearDown(self): self.db.clear() def test_add(self): """Check whether everything works ok when adding organizations and domains""" code = self.cmd.add('Example') self.assertEqual(code, CMD_SUCCESS) code = self.cmd.add('Example', 'example.com') self.assertEqual(code, CMD_SUCCESS) code = self.cmd.add('Bitergia') self.assertEqual(code, CMD_SUCCESS) code = self.cmd.add('Bitergia', 'bitergia.net') self.assertEqual(code, CMD_SUCCESS) code = self.cmd.add('Bitergia', 'bitergia.com', is_top_domain=True) self.assertEqual(code, CMD_SUCCESS) code = self.cmd.add('LibreSoft', '') # This will work like adding a organization self.assertEqual(code, CMD_SUCCESS) code = self.cmd.add('Example', 'example.org') self.assertEqual(code, CMD_SUCCESS) code = self.cmd.add('Example', 'example.net') self.assertEqual(code, CMD_SUCCESS) # List the registry and check the output self.cmd.registry() output = sys.stdout.getvalue().strip() self.assertEqual(output, REGISTRY_OUTPUT) def test_existing_organization(self): """Check if it fails adding an organization that already exists""" code1 = self.cmd.add('Bitergium') self.assertEqual(code1, CMD_SUCCESS) code2 = self.cmd.add('Bitergium') self.assertEqual(code2, CODE_ALREADY_EXISTS_ERROR) output = sys.stderr.getvalue().strip() self.assertEqual(output, REGISTRY_ORG_ALREADY_EXISTS_ERROR) def test_non_existing_organization(self): """Check if it fails adding domains to not existing organizations""" code = self.cmd.add('Bitergium', 'bitergium.com') self.assertEqual(code, CODE_NOT_FOUND_ERROR) output = sys.stderr.getvalue().strip() self.assertEqual(output, REGISTRY_ORG_NOT_FOUND_ERROR) def test_existing_domain(self): """Check if it fails adding a domain that already exists""" # Add a pair of organizations and domains first self.cmd.add('Example') self.cmd.add('Example', 'example.com') self.cmd.add('Bitergia') self.cmd.add('Bitergia', 'bitergia.com') # Add 'bitergia.com' to 'Example' org # It should print an error code = self.cmd.add('Example', 'bitergia.com') self.assertEqual(code, CODE_ALREADY_EXISTS_ERROR) output = sys.stderr.getvalue().strip() self.assertEqual(output, REGISTRY_DOM_ALREADY_EXISTS_ERROR) def test_overwrite_domain(self): """Check whether it overwrites the old organization-domain relationship and the top_domain flag""" # Add a pair of organizations and domains first self.cmd.add('Example') self.cmd.add('Example', 'example.com') self.cmd.add('Example', 'example.org') self.cmd.add('Bitergia') self.cmd.add('Bitergia', 'bitergia.com') # Overwrite the relationship assigning the domain to a different # company and top_domain flag code = self.cmd.add('Bitergia', 'example.com', is_top_domain=True, overwrite=True) self.assertEqual(code, CMD_SUCCESS) output = sys.stdout.getvalue().strip() self.assertEqual(output, REGISTRY_EMPTY_OUTPUT) # Check if the domain has been assigned to Bitergia orgs = api.registry(self.db) org1 = orgs[0] self.assertEqual(org1.name, 'Bitergia') doms1 = org1.domains doms1.sort(key=lambda x: x.domain) self.assertEqual(len(doms1), 2) dom = doms1[0] self.assertEqual(dom.domain, 'bitergia.com') dom = doms1[1] self.assertEqual(dom.domain, 'example.com') self.assertEqual(dom.is_top_domain, True) org2 = orgs[1] self.assertEqual(org2.name, 'Example') doms2 = org2.domains doms2.sort(key=lambda x: x.domain) self.assertEqual(len(doms2), 1) dom1 = doms2[0] self.assertEqual(dom1.domain, 'example.org') def test_none_organization(self): """Check behavior adding None organizations""" code = self.cmd.add(None) self.assertEqual(code, CMD_SUCCESS) output = sys.stdout.getvalue().strip() self.assertEqual(output, REGISTRY_EMPTY_OUTPUT) # The registry should be empty orgs = api.registry(self.db) self.assertEqual(len(orgs), 0) def test_empty_organization(self): """Check behavior adding empty organizations""" code = self.cmd.add('') self.assertEqual(code, CMD_SUCCESS) output = sys.stdout.getvalue().strip() self.assertEqual(output, REGISTRY_EMPTY_OUTPUT) # The registry should be empty orgs = api.registry(self.db) self.assertEqual(len(orgs), 0)
class TestOrgsDelete(unittest.TestCase): def setUp(self): if not hasattr(sys.stdout, 'getvalue'): self.fail('This test needs to be run in buffered mode') # Create a connection to check the contents of the registry self.db = Database(DB_USER, DB_PASSWORD, DB_NAME, DB_HOST, DB_PORT) # Create command self.kwargs = {'user' : DB_USER, 'password' : DB_PASSWORD, 'database' :DB_NAME, 'host' : DB_HOST, 'port' : DB_PORT} self.cmd = Organizations(**self.kwargs) def tearDown(self): self.db.clear() def test_delete(self): """Check whether everything works ok when deleting organizations and domains""" # First, add a set of organizations, including some domains self.cmd.add('Example') self.cmd.add('Example', 'example.com') self.cmd.add('Example', 'example.org') self.cmd.add('Example', 'example.net') self.cmd.add('Bitergia') self.cmd.add('Bitergia', 'bitergia.com') self.cmd.add('LibreSoft') self.cmd.add('Bitergium') self.cmd.add('Bitergium', 'bitergium.com') self.cmd.add('Bitergium', 'bitergium.net') # Delete an organization orgs = api.registry(self.db, 'Bitergia') self.assertEqual(len(orgs), 1) code = self.cmd.delete('Bitergia') self.assertEqual(code, CMD_SUCCESS) self.assertRaises(NotFoundError, api.registry, self.db, 'Bitergia') # Delete a domain orgs = api.registry(self.db, 'Bitergium') self.assertEqual(len(orgs[0].domains), 2) code = self.cmd.delete('Bitergium', 'bitergium.com') self.assertEqual(code, CMD_SUCCESS) orgs = api.registry(self.db, 'Bitergium') self.assertEqual(len(orgs[0].domains), 1) # Delete organization with several domains orgs = api.registry(self.db, 'Example') self.assertEqual(len(orgs), 1) code = self.cmd.delete('Example') self.assertEqual(code, CMD_SUCCESS) self.assertRaises(NotFoundError, api.registry, self.db, 'Example') # The final content of the registry should have # two companies and one domain orgs = api.registry(self.db) self.assertEqual(len(orgs), 2) org1 = orgs[0] self.assertEqual(org1.name, 'Bitergium') doms1 = org1.domains self.assertEqual(len(doms1), 1) self.assertEqual(doms1[0].domain, 'bitergium.net') org2 = orgs[1] self.assertEqual(org2.name, 'LibreSoft') doms2 = org2.domains self.assertEqual(len(doms2), 0) def test_not_found_organization(self): """Check if it fails removing an organization that does not exists""" # It should print an error when the registry is empty code = self.cmd.delete('Bitergium') self.assertEqual(code, CODE_NOT_FOUND_ERROR) output = sys.stderr.getvalue().strip().split('\n')[0] self.assertEqual(output, REGISTRY_ORG_NOT_FOUND_ERROR) # Add a pair of organizations to check delete with a registry # with contents self.cmd.add('Example') self.cmd.add('Bitergia') self.cmd.add('Bitergia', 'bitergia.com') # The error should be the same code = self.cmd.delete('Bitergium') self.assertEqual(code, CODE_NOT_FOUND_ERROR) output = sys.stderr.getvalue().strip().split('\n')[1] self.assertEqual(output, REGISTRY_ORG_NOT_FOUND_ERROR) # It fails again, when trying to delete a domain from # a organization that does not exist code = self.cmd.delete('LibreSoft', 'bitergium.com') self.assertEqual(code, CODE_NOT_FOUND_ERROR) output = sys.stderr.getvalue().strip().split('\n')[2] self.assertEqual(output, REGISTRY_ORG_NOT_FOUND_ERROR_ALT) # Nothing has been deleted from the registry orgs = api.registry(self.db) self.assertEqual(len(orgs), 2) self.assertEqual(len(orgs[0].domains), 1) self.assertEqual(len(orgs[1].domains), 0) def test_not_found_domain(self): """Check if it fails removing an domain that does not exists""" # Add a pair of organizations to check delete with a registry # with contents self.cmd.add('Example') self.cmd.add('Bitergia') self.cmd.add('Bitergia', 'bitergia.com') code = self.cmd.delete('Example', 'example.com') self.assertEqual(code, CODE_NOT_FOUND_ERROR) output = sys.stderr.getvalue().strip().split('\n')[0] self.assertEqual(output, REGISTRY_DOM_NOT_FOUND_ERROR) # It should not fail because the domain is assigned # to other organization code = self.cmd.delete('Example', 'bitergia.com') self.assertEqual(code, CODE_NOT_FOUND_ERROR) output = sys.stderr.getvalue().strip().split('\n')[1] self.assertEqual(output, REGISTRY_DOM_NOT_FOUND_ERROR_ALT) # Nothing has been deleted from the registry orgs = api.registry(self.db) self.assertEqual(len(orgs), 2) self.assertEqual(len(orgs[0].domains), 1) self.assertEqual(len(orgs[1].domains), 0)
class TestBaseCase(unittest.TestCase): """Defines common setup and teardown methods on add unit tests""" def setUp(self): if not hasattr(sys.stdout, 'getvalue') and not hasattr( sys.stderr, 'getvalue'): self.fail('This test needs to be run in buffered mode') # Create a connection to check the contents of the registry self.db = Database(DB_USER, DB_PASSWORD, DB_NAME, DB_HOST, DB_PORT) self.db.clear() self._load_test_dataset() # Create command self.kwargs = { 'user': DB_USER, 'password': DB_PASSWORD, 'database': DB_NAME, 'host': DB_HOST, 'port': DB_PORT } self.cmd = Merge(**self.kwargs) def tearDown(self): self.db.clear() def _load_test_dataset(self): # Add country with self.db.connect() as session: # Add a country us = Country(code='US', name='United States of America', alpha3='USA') session.add(us) api.add_unique_identity(self.db, 'John Smith') api.add_identity(self.db, 'scm', '*****@*****.**', uuid='John Smith') api.add_identity(self.db, 'scm', '*****@*****.**', 'John Smith', uuid='John Smith') api.edit_profile(self.db, 'John Smith', name='John Smith', is_bot=False) api.add_unique_identity(self.db, 'John Doe') api.add_identity(self.db, 'scm', '*****@*****.**', uuid='John Doe') api.edit_profile(self.db, 'John Doe', email='*****@*****.**', is_bot=True, country_code='US') api.add_organization(self.db, 'Example') api.add_enrollment(self.db, 'John Smith', 'Example') api.add_enrollment(self.db, 'John Doe', 'Example') api.add_organization(self.db, 'Bitergia') api.add_enrollment(self.db, 'John Smith', 'Bitergia') api.add_enrollment(self.db, 'John Doe', 'Bitergia', datetime.datetime(1999, 1, 1), datetime.datetime(2000, 1, 1)) api.add_organization(self.db, 'LibreSoft')
class TestBlacklistCommand(unittest.TestCase): """Blacklist command unit tests""" def setUp(self): if not hasattr(sys.stdout, 'getvalue'): self.fail('This test needs to be run in buffered mode') # Create a connection to check the contents of the registry self.db = Database(DB_USER, DB_PASSWORD, DB_NAME, DB_HOST, DB_PORT) # Create command self.kwargs = {'user' : DB_USER, 'password' : DB_PASSWORD, 'database' :DB_NAME, 'host' : DB_HOST, 'port' : DB_PORT} self.cmd = Blacklist(**self.kwargs) def tearDown(self): self.db.clear() def test_default_action(self): """Check whether when no action is given it runs --list""" self.__load_test_dataset() code = self.cmd.run() self.assertEqual(code, CMD_SUCCESS) output = sys.stdout.getvalue().strip() self.assertEqual(output, BLACKLIST_OUTPUT) def test_list_without_args(self): """Test list action with and without arguments""" self.__load_test_dataset() code = self.cmd.run('-l') self.assertEqual(code, CMD_SUCCESS) output = sys.stdout.getvalue().strip() self.assertEqual(output, BLACKLIST_OUTPUT) def test_list_with_args(self): """Test list action with arguments""" self.__load_test_dataset() code = self.cmd.run('--list', 'ohn') self.assertEqual(code, CMD_SUCCESS) output = sys.stdout.getvalue().strip() self.assertEqual(output, BLACKLIST_OUTPUT_JOHN) def test_add_with_args(self): """Test add action""" code = self.cmd.run('--add', 'John Smith') self.assertEqual(code, CMD_SUCCESS) code = self.cmd.run('-a', 'Bitergia') self.assertEqual(code, CMD_SUCCESS) code = self.cmd.run('--add', 'John Doe') self.assertEqual(code, CMD_SUCCESS) code = self.cmd.run('-a', '*****@*****.**') self.assertEqual(code, CMD_SUCCESS) code = self.cmd.run('--list') self.assertEqual(code, CMD_SUCCESS) # Check output output = sys.stdout.getvalue().strip() self.assertEqual(output, BLACKLIST_OUTPUT) def test_add_without_args(self): """Check when calling --add without args, it does not do anything""" code = self.cmd.run('--add') self.assertEqual(code, CMD_SUCCESS) code = self.cmd.run('-l') self.assertEqual(code, CMD_SUCCESS) output = sys.stdout.getvalue().strip() self.assertEqual(output, BLACKLIST_EMPTY_OUTPUT) def test_delete_with_args(self): """Test delete action""" self.__load_test_dataset() # Delete contents code = self.cmd.run('--delete', 'Bitergia') self.assertEqual(code, CMD_SUCCESS) code = self.cmd.run('-d', 'John Doe') self.assertEqual(code, CMD_SUCCESS) code = self.cmd.run('--list') self.assertEqual(code, CMD_SUCCESS) # Check output output = sys.stdout.getvalue().strip() self.assertEqual(output, BLACKLIST_OUTPUT_ALT) def test_delete_without_args(self): """Check when calling --delete without args, it does not do anything""" self.__load_test_dataset() code = self.cmd.run('--delete') self.assertEqual(code, CMD_SUCCESS) code = self.cmd.run('-l') self.assertEqual(code, CMD_SUCCESS) # Check output output = sys.stdout.getvalue().strip() self.assertEqual(output, BLACKLIST_OUTPUT) def test_run_mixing_actions(self): """Check how it works when mixing actions""" self.cmd.run('--add', 'John Doe') self.cmd.run('-a', 'John Smith') self.cmd.run('-a', 'Example') self.cmd.run('--add', 'Bitergia') self.cmd.run('-d', 'Bitergia') self.cmd.run('--add', '*****@*****.**') self.cmd.run('-a', '*****@*****.**') self.cmd.run('--delete', 'John Doe') self.cmd.run('--delete', '*****@*****.**') self.cmd.run('--add', '*****@*****.**') self.cmd.run('-d', '*****@*****.**') self.cmd.run('--delete', 'Example') self.cmd.run() output = sys.stdout.getvalue().strip() self.assertEqual(output, BLACKLIST_OUTPUT_ALT) def __load_test_dataset(self): self.cmd.add('*****@*****.**') self.cmd.add('John Smith') self.cmd.add('Bitergia') self.cmd.add('John Doe')
class TestAdd(unittest.TestCase): """Blacklist add sub-command unit tests""" def setUp(self): if not hasattr(sys.stdout, 'getvalue'): self.fail('This test needs to be run in buffered mode') # Create a connection to check the contents of the registry self.db = Database(DB_USER, DB_PASSWORD, DB_NAME, DB_HOST, DB_PORT) # Create command self.kwargs = {'user' : DB_USER, 'password' : DB_PASSWORD, 'database' :DB_NAME, 'host' : DB_HOST, 'port' : DB_PORT} self.cmd = Blacklist(**self.kwargs) def tearDown(self): self.db.clear() def test_add(self): """Check whether everything works ok when adding entries""" self.cmd.add('*****@*****.**') self.cmd.add('John Smith') self.cmd.add('Bitergia') self.cmd.add('John Doe') # List the registry and check the output code = self.cmd.blacklist() self.assertEqual(code, CMD_SUCCESS) output = sys.stdout.getvalue().strip() self.assertEqual(output, BLACKLIST_OUTPUT) def test_existing_entry(self): """Check if it fails adding an entry that already exists""" code = self.cmd.add('*****@*****.**') self.assertEqual(code, CMD_SUCCESS) code = self.cmd.add('*****@*****.**') self.assertEqual(code, CODE_ALREADY_EXISTS_ERROR) output = sys.stderr.getvalue().strip() self.assertEqual(output, BLACKLIST_ALREADY_EXISTS_ERROR) def test_none_entry(self): """Check behavior adding None entries""" code = self.cmd.add(None) self.assertEqual(code, CMD_SUCCESS) output = sys.stdout.getvalue().strip() self.assertEqual(output, BLACKLIST_EMPTY_OUTPUT) # The blacklist should be empty bl = api.blacklist(self.db) self.assertEqual(len(bl), 0) def test_empty_entry(self): """Check behavior adding empty organizations""" code = self.cmd.add('') self.assertEqual(code, CMD_SUCCESS) output = sys.stdout.getvalue().strip() self.assertEqual(output, BLACKLIST_EMPTY_OUTPUT) # The blacklist should be empty bl = api.blacklist(self.db) self.assertEqual(len(bl), 0)
class TestDelete(unittest.TestCase): """Blacklist delete sub-command unit tests""" def setUp(self): if not hasattr(sys.stdout, 'getvalue'): self.fail('This test needs to be run in buffered mode') # Create a connection to check the contents of the registry self.db = Database(DB_USER, DB_PASSWORD, DB_NAME, DB_HOST, DB_PORT) # Create command self.kwargs = {'user' : DB_USER, 'password' : DB_PASSWORD, 'database' :DB_NAME, 'host' : DB_HOST, 'port' : DB_PORT} self.cmd = Blacklist(**self.kwargs) def tearDown(self): self.db.clear() def test_delete(self): """Check whether everything works ok when deleting entries""" # First, add a set of entries self.cmd.add('*****@*****.**') self.cmd.add('John Smith') self.cmd.add('Bitergia') self.cmd.add('John Doe') # Delete an entry bl = api.blacklist(self.db, 'Bitergia') self.assertEqual(len(bl), 1) code = self.cmd.delete('Bitergia') self.assertEqual(code, CMD_SUCCESS) self.assertRaises(NotFoundError, api.blacklist, self.db, 'Bitergia') code = self.cmd.delete('*****@*****.**') self.assertEqual(code, CMD_SUCCESS) # The final content of the registry should have # two entries bl = api.blacklist(self.db) self.assertEqual(len(bl), 2) e = bl[0] self.assertEqual(e.excluded, 'John Doe') e = bl[1] self.assertEqual(e.excluded, 'John Smith') def test_not_found_entry(self): """Check if it fails removing an entry that does not exists""" # It should print an error when the blacklist is empty code = self.cmd.delete('*****@*****.**') self.assertEqual(code, CODE_NOT_FOUND_ERROR) output = sys.stderr.getvalue().strip().split('\n')[0] self.assertEqual(output, BLACKLIST_NOT_FOUND_ERROR) # Add a pair of entries to check delete with a blacklist # with contents self.cmd.add('John Smith') self.cmd.add('*****@*****.**') # The error should be the same code = self.cmd.delete('*****@*****.**') self.assertEqual(code, CODE_NOT_FOUND_ERROR) output = sys.stderr.getvalue().strip().split('\n')[1] self.assertEqual(output, BLACKLIST_NOT_FOUND_ERROR) # Nothing has been deleted from the registry bl = api.blacklist(self.db) self.assertEqual(len(bl), 2)
class TestBaseCase(unittest.TestCase): """Defines common setup and teardown methods on show unit tests""" def setUp(self): if not hasattr(sys.stdout, 'getvalue'): self.fail('This test needs to be run in buffered mode') # Create a connection to check the contents of the registry self.db = Database(DB_USER, DB_PASSWORD, DB_NAME, DB_HOST, DB_PORT) # Import predefined dataset for testing self._load_test_dataset() # Create command self.kwargs = { 'user': DB_USER, 'password': DB_PASSWORD, 'database': DB_NAME, 'host': DB_HOST, 'port': DB_PORT } self.cmd = Show(**self.kwargs) def tearDown(self): self.db.clear() def _load_test_dataset(self): # Add country with self.db.connect() as session: # Add a country us = Country(code='US', name='United States of America', alpha3='USA') session.add(us) # Add organizations api.add_organization(self.db, 'Example') api.add_organization(self.db, 'Bitergia') # Add John Smith identity jsmith_uuid = api.add_identity(self.db, 'scm', '*****@*****.**', 'John Smith', 'jsmith') api.add_identity(self.db, 'scm', '*****@*****.**', 'John Smith', uuid=jsmith_uuid) api.edit_profile(self.db, jsmith_uuid, email='*****@*****.**', is_bot=True) # Add Joe Roe identity jroe_uuid = api.add_identity(self.db, 'scm', '*****@*****.**', 'Jane Roe', 'jroe') api.add_identity(self.db, 'scm', '*****@*****.**', uuid=jroe_uuid) api.add_identity(self.db, 'unknown', '*****@*****.**', uuid=jroe_uuid) api.edit_profile(self.db, jroe_uuid, name='Jane Roe', email='*****@*****.**', is_bot=False, country_code='US') # Add unique identity, this one won't have neither identities # nor enrollments api.add_unique_identity(self.db, '0000000000000000000000000000000000000000') # Add enrollments api.add_enrollment(self.db, jsmith_uuid, 'Example') api.add_enrollment(self.db, jroe_uuid, 'Example') api.add_enrollment(self.db, jroe_uuid, 'Bitergia', datetime.datetime(1999, 1, 1), datetime.datetime(2000, 1, 1)) api.add_enrollment(self.db, jroe_uuid, 'Bitergia', datetime.datetime(2006, 1, 1), datetime.datetime(2008, 1, 1))
class TestBaseCase(unittest.TestCase): """Defines common setup and teardown methods on affiliate unit tests""" def setUp(self): if not hasattr(sys.stdout, 'getvalue') and not hasattr( sys.stderr, 'getvalue'): self.fail('This test needs to be run in buffered mode') # Create a connection to check the contents of the registry self.db = Database(DB_USER, DB_PASSWORD, DB_NAME, DB_HOST, DB_PORT) self._load_test_dataset() # Create command self.kwargs = { 'user': DB_USER, 'password': DB_PASSWORD, 'database': DB_NAME, 'host': DB_HOST, 'port': DB_PORT } self.cmd = Affiliate(**self.kwargs) def tearDown(self): self.db.clear() def _load_test_dataset(self): # Add some domains api.add_organization(self.db, 'Example') api.add_domain(self.db, 'Example', 'example.com', is_top_domain=True) api.add_organization(self.db, 'Example Alt') api.add_domain(self.db, 'Example Alt', 'u.example.com', is_top_domain=True) api.add_domain(self.db, 'Example Alt', 'es.u.example.com') api.add_domain(self.db, 'Example Alt', 'en.u.example.com') api.add_organization(self.db, 'Bitergia') api.add_domain(self.db, 'Bitergia', 'bitergia.com') api.add_domain(self.db, 'Bitergia', 'bitergia.org') api.add_organization(self.db, 'LibreSoft') # Add some unique identities jsmith_uuid = api.add_identity(self.db, 'scm', '*****@*****.**', 'John Smith', 'jsmith') api.add_identity(self.db, 'scm', '*****@*****.**', 'John Smith', uuid=jsmith_uuid) api.add_identity(self.db, 'scm', '*****@*****.**', 'John Smith', 'jsmith', uuid=jsmith_uuid) api.add_enrollment(self.db, jsmith_uuid, 'Bitergia') # Add John Doe identity api.add_identity(self.db, 'unknown', None, 'John Doe', 'jdoe') # Add Jane Rae identity jroe_uuid = api.add_identity(self.db, 'scm', '*****@*****.**', 'Jane Roe', 'jroe') api.add_identity(self.db, 'scm', '*****@*****.**', uuid=jroe_uuid) api.add_identity(self.db, 'unknown', '*****@*****.**', uuid=jroe_uuid)
class TestBaseCase(unittest.TestCase): """Defines common setup and teardown methods on show unit tests""" def setUp(self): if not hasattr(sys.stdout, 'getvalue'): self.fail('This test needs to be run in buffered mode') # Create a connection to check the contents of the registry self.db = Database(DB_USER, DB_PASSWORD, DB_NAME, DB_HOST, DB_PORT) # Import predefined dataset for testing self._load_test_dataset() # Create command self.kwargs = {'user' : DB_USER, 'password' : DB_PASSWORD, 'database' :DB_NAME, 'host' : DB_HOST, 'port' : DB_PORT} self.cmd = Show(**self.kwargs) def tearDown(self): self.db.clear() def _load_test_dataset(self): # Add country with self.db.connect() as session: # Add a country us = Country(code='US', name='United States of America', alpha3='USA') session.add(us) # Add organizations api.add_organization(self.db, 'Example') api.add_organization(self.db, 'Bitergia') # Add John Smith identity jsmith_uuid = api.add_identity(self.db, 'scm', '*****@*****.**', 'John Smith', 'jsmith') api.add_identity(self.db, 'scm', '*****@*****.**', 'John Smith', uuid=jsmith_uuid) api.edit_profile(self.db, jsmith_uuid, email='*****@*****.**', is_bot=True) # Add Joe Roe identity jroe_uuid = api.add_identity(self.db, 'scm', '*****@*****.**', 'Jane Roe', 'jroe') api.add_identity(self.db, 'scm', '*****@*****.**', uuid=jroe_uuid) api.add_identity(self.db, 'unknown', '*****@*****.**', uuid=jroe_uuid) api.edit_profile(self.db, jroe_uuid, name='Jane Roe', email='*****@*****.**', is_bot=False, country_code='US') # Add unique identity, this one won't have neither identities # nor enrollments api.add_unique_identity(self.db, '0000000000000000000000000000000000000000') # Add enrollments api.add_enrollment(self.db, jsmith_uuid, 'Example') api.add_enrollment(self.db, jroe_uuid, 'Example') api.add_enrollment(self.db, jroe_uuid, 'Bitergia', datetime.datetime(1999, 1, 1), datetime.datetime(2000, 1, 1)) api.add_enrollment(self.db, jroe_uuid, 'Bitergia', datetime.datetime(2006, 1, 1), datetime.datetime(2008, 1, 1))
class TestBaseCase(unittest.TestCase): """Defines common setup and teardown methods on unify unit tests""" def setUp(self): if not hasattr(sys.stdout, 'getvalue') and not hasattr( sys.stderr, 'getvalue'): self.fail('This test needs to be run in buffered mode') # Create a connection to check the contents of the registry self.db = Database(DB_USER, DB_PASSWORD, DB_NAME, DB_HOST, DB_PORT) self._load_test_dataset() # Create command self.kwargs = { 'user': DB_USER, 'password': DB_PASSWORD, 'database': DB_NAME, 'host': DB_HOST, 'port': DB_PORT } self.cmd = Unify(**self.kwargs) def tearDown(self): self.db.clear() def _load_test_dataset(self): # Add some unique identities uuid = api.add_identity(self.db, source='scm', email='*****@*****.**', name='John Smith') api.add_identity(self.db, source='scm', name='John Smith', uuid=uuid) api.add_identity(self.db, source='scm', username='******', uuid=uuid) uuid = api.add_identity(self.db, source='alt', name='J. Smith', username='******') api.add_identity(self.db, source='alt', name='John Smith', username='******', uuid=uuid) api.add_identity(self.db, source='alt', email='jsmith', uuid=uuid) uuid = api.add_identity(self.db, source='scm', name='Jane Rae') api.add_identity(self.db, source='mls', email='*****@*****.**', name='Jane Rae Doe', uuid=uuid) uuid = api.add_identity(self.db, source='scm', name='J. Smith', username='******') api.add_identity(self.db, source='scm', username='******', uuid=uuid) api.add_identity(self.db, source='mls', username='******', uuid=uuid) api.add_identity(self.db, source='mls', email='*****@*****.**', name='Smith. J', uuid=uuid) uuid = api.add_identity(self.db, source='mls', email='*****@*****.**', name='Jane Rae Doe') api.add_identity(self.db, source='mls', name='jrae', uuid=uuid) uuid = api.add_identity(self.db, source='scm', name='jrae')
class TestBaseCase(unittest.TestCase): """Defines common setup and teardown methods on show unit tests""" def setUp(self): import tempfile if not hasattr(sys.stdout, 'getvalue'): self.fail('This test needs to be run in buffered mode') # Create a connection to check the contents of the registry self.db = Database(DB_USER, DB_PASSWORD, DB_NAME, DB_HOST, DB_PORT) # Import predefined dataset for testing self._load_test_dataset() # Temporary file for outputs self.tmpfile = tempfile.mkstemp()[1] # Create command self.kwargs = {'user' : DB_USER, 'password' : DB_PASSWORD, 'database' : DB_NAME, 'host' : DB_HOST, 'port' : DB_PORT} self.cmd = Export(**self.kwargs) def tearDown(self): import os self.db.clear() os.remove(self.tmpfile) def read_json(self, filename): if sys.version_info[0] >= 3: # Python 3 with open(filename, 'r', encoding='UTF-8') as f: content = f.read() else: # Python 2 with open(filename, 'r') as f: content = f.read().decode('UTF-8') obj = json.loads(content) return obj def _load_test_dataset(self): import datetime self.db.clear() # Add country with self.db.connect() as session: # Add a country us = Country(code='US', name='United States of America', alpha3='USA') session.add(us) # Add organizations api.add_organization(self.db, 'Example') api.add_domain(self.db, 'Example', 'example.com', is_top_domain=True) api.add_domain(self.db, 'Example', 'example.net', is_top_domain=True) api.add_organization(self.db, 'Bitergia') api.add_domain(self.db, 'Bitergia', 'bitergia.net', is_top_domain=True) api.add_domain(self.db, 'Bitergia', 'bitergia.com', is_top_domain=True) api.add_domain(self.db, 'Bitergia', 'api.bitergia.com', is_top_domain=False) api.add_domain(self.db, 'Bitergia', 'test.bitergia.com', is_top_domain=False) api.add_organization(self.db, 'Unknown') # Add John Smith identity jsmith_uuid = api.add_identity(self.db, 'scm', '*****@*****.**', 'John Smith', 'jsmith') api.add_identity(self.db, 'scm', '*****@*****.**', 'John Smith', uuid=jsmith_uuid) api.edit_profile(self.db, jsmith_uuid, email='*****@*****.**', is_bot=True) # Add Joe Roe identity jroe_uuid = api.add_identity(self.db, 'scm', '*****@*****.**', 'Jane Roe', 'jroe') api.add_identity(self.db, 'scm', '*****@*****.**', uuid=jroe_uuid) api.add_identity(self.db, 'unknown', '*****@*****.**', uuid=jroe_uuid) api.edit_profile(self.db, jroe_uuid, name='Jane Roe', email='*****@*****.**', is_bot=False, country_code='US') # Add unique identity, this one won't have neither identities # nor enrollments api.add_unique_identity(self.db, '0000000000000000000000000000000000000000') # Add enrollments api.add_enrollment(self.db, jsmith_uuid, 'Example') api.add_enrollment(self.db, jroe_uuid, 'Example') api.add_enrollment(self.db, jroe_uuid, 'Bitergia', datetime.datetime(1999, 1, 1), datetime.datetime(2000, 1, 1)) api.add_enrollment(self.db, jroe_uuid, 'Bitergia', datetime.datetime(2006, 1, 1), datetime.datetime(2008, 1, 1)) # Add blacklist api.add_to_matching_blacklist(self.db, '*****@*****.**') api.add_to_matching_blacklist(self.db, 'John Smith')