text: # -*- coding: utf-8 -*-
  
  """Tests for the metaregistry."""
  
  import unittest
  
  import bioregistry
  from bioregistry.export.rdf_export import metaresource_to_rdf_str
  from bioregistry.schema import Registry
  
  
  class TestMetaregistry(unittest.TestCase):
      """Tests for the metaregistry."""
  
      def test_minimum_metadata(self):
          """Test the metaregistry entries have a minimum amount of data."""
          for metaprefix, registry_pydantic in bioregistry.read_metaregistry().items():
              self.assertIsInstance(registry_pydantic, Registry)
              data = registry_pydantic.dict()
              with self.subTest(metaprefix=metaprefix):
                  self.assertIn('name', data)
                  self.assertIn('homepage', data)
                  self.assertIn('example', data)
                  self.assertIn('description', data)
  
                  # When a registry is a provider, it means it
                  # provides for its entries
                  self.assertIn('provider', data)
                  if data['provider']:
                      self.assertIn('provider_url', data)
                      self.assertIn('$1', data['provider_url'])
  
                  # When a registry is a resolver, it means it
                  # can resolve entries (prefixes) + identifiers
                  self.assertIn('resolver', data)
                  if data['resolver']:
                      self.assertIn('resolver_url', data)
                      self.assertIn('$1', data['resolver_url'])
                      self.assertIn('$2', data['resolver_url'])
  
                  invalid_keys = set(data).difference({
                      'prefix', 'name', 'homepage', 'download',
                      'provider', 'resolver', 'description', 'provider_url',
                      'example', 'resolver_url', 'contact',
                  })
                  self.assertEqual(set(), invalid_keys, msg='invalid metadata')
  
      def test_get_registry(self):
          """Test getting a registry."""
          self.assertIsNone(bioregistry.get_registry('nope'))
          self.assertIsNone(bioregistry.get_registry_name('nope'))
          self.assertIsNone(bioregistry.get_registry_homepage('nope'))
          self.assertIsNone(bioregistry.get_registry_url('nope', ...))
          self.assertIsNone(bioregistry.get_registry_example('nope'))
          self.assertIsNone(bioregistry.get_registry_description('nope'))
          self.assertIsNone(bioregistry.get_registry_url('n2t', ...))  # no provider available for N2T registry
  
          metaprefix = 'uniprot'
          registry = bioregistry.get_registry(metaprefix)
          self.assertIsInstance(registry, Registry)
          self.assertEqual(metaprefix, registry.prefix)
  
          self.assertEqual(registry.description, bioregistry.get_registry_description(metaprefix))
  
          homepage = 'https://www.uniprot.org/database/'
          self.assertEqual(homepage, registry.homepage)
          self.assertEqual(homepage, bioregistry.get_registry_homepage(metaprefix))
  
          name = 'UniProt Cross-ref database'
          self.assertEqual(name, registry.name)
          self.assertEqual(name, bioregistry.get_registry_name(metaprefix))
  
          example = '0174'
          self.assertEqual(example, registry.example)
          self.assertEqual(example, bioregistry.get_registry_example(metaprefix))
  
          url = bioregistry.get_registry_url(metaprefix, example)
          self.assertEqual('https://www.uniprot.org/database/DB-0174', url)
  
      def test_resolver(self):
          """Test generating resolver URLs."""
          # Can't resolve since nope isn't a valid registry
          self.assertIsNone(bioregistry.get_registry_resolve_url('nope', 'chebi', '1234'))
          # Can't resolve since GO isn't a resolver
          self.assertIsNone(bioregistry.get_registry_resolve_url('go', 'chebi', '1234'))
  
          url = bioregistry.get_registry_resolve_url('bioregistry', 'chebi', '1234')
          self.assertEqual('https://bioregistry.io/chebi:1234', url)
  
      def test_get_rdf(self):
          """Test conversion to RDF."""
          s = metaresource_to_rdf_str('uniprot')
          self.assertIsInstance(s, str)
  