def __init__(self, generator=None, **kwargs):
self.rsxml = RsXML()
Observable.__init__(self)
self.params = Parameters(**kwargs)
LOG.debug("ResourceSync initialized with the configuration provided.")
self._generator = None
self.set_generator(generator)
def test_zero_fill_filename(self):
Parameters(zero_fill_filename=2)
with self.assertRaises(ValueError):
Parameters(zero_fill_filename=20)
with self.assertRaises(ValueError):
Parameters(zero_fill_filename="ggg")
def test_metadata_dir(self):
params = Parameters(metadata_dir="rs_metadata")
self.assert_params(params)
with self.assertRaises(ValueError):
Parameters(metadata_dir="")
with self.assertRaises(ValueError):
Parameters(metadata_dir="/etc/metadata")
def test_max_items_in_list(self):
Parameters(max_items_in_list=1000)
Parameters(max_items_in_list=None)
with self.assertRaises(ValueError):
Parameters(max_items_in_list=100000)
with self.assertRaises(ValueError):
Parameters(max_items_in_list="ssssss")
def test_description_dir(self):
params = Parameters(description_dir="/etc")
self.assert_params(params)
with self.assertRaises(AssertionError):
Parameters(description_dir=1)
with self.assertRaises(ValueError):
Parameters(description_dir="XXXX")
with self.assertRaises(ValueError):
Parameters(description_dir="/etc/bashrc")
def test_resource_dir(self):
params = Parameters(resource_dir="/etc")
self.assert_params(params)
with self.assertRaises(AssertionError):
Parameters(resource_dir=1111)
with self.assertRaises(ValueError):
Parameters(resource_dir="XXXX")
with self.assertRaises(ValueError):
Parameters(resource_dir="/etc/bashrc")
def test_convert_to_xml(self):
params = Parameters(
metadata_dir="testmd"
)
eg = EgGenerator(params)
rsxml = RsXML()
xml = rsxml.convert_to_xml(eg.generate())
assert xml is not None
def test_strategy(self):
Parameters(strategy=0)
Parameters(strategy=1)
Parameters(strategy=2)
Parameters(strategy="resourcelist")
Parameters(strategy="new_changelist")
Parameters(strategy="inc_changelist")
# id strategy is none, the default will be picked
Parameters(strategy=None)
with self.assertRaises(ValueError):
Parameters(strategy="sfasdadasdsa")
with self.assertRaises(ValueError):
Parameters(strategy=100)
def __init__(self, parameters: Parameters = None):
"""
:samp:`Initialization`
If no :class:`~rspub.core.rs_paras.RsParameters` were given will construct
new :class:`~rspub.core.rs_paras.RsParameters` from
configuration found under :func:`~rspub.core.config.Configurations.current_configuration_name`.
:param parameters: :class:`~rspub.core.rs_paras.RsParameters` for execution
"""
Observable.__init__(self)
self.param = parameters if parameters else Parameters()
self.passes_resource_gate = None
self.date_start_processing = None
self.date_end_processing = None
def test_url_prefix(self):
params = Parameters(url_prefix="http://www.resourcesync.org/")
self.assert_params(params)
params = Parameters(url_prefix="http://localhost")
self.assert_params(params)
params = Parameters(url_prefix="http://localhost:9000")
self.assert_params(params)
Parameters(url_prefix="http://safsfaasdgasf")
self.assert_params(params)
with self.assertRaises(ValueError):
Parameters(url_prefix="//www.resourcesync.org")
with self.assertRaises(ValueError):
Parameters(url_prefix="ftp://www.resourcesync.org")
with self.assertRaises(ValueError):
Parameters(url_prefix="http://www.resourcesync.org/#fragments")
with self.assertRaises(ValueError):
Parameters(
url_prefix="http://www.resourcesync.org?query=parameters")
def test_kwargs(self):
params = Parameters(new_param="ss")
assert params.new_param == 'ss'
class ResourceSync(Observable):
"""
:samp: Main class for publishing ResourceSync documents.
"""
def __init__(self, generator=None, **kwargs):
self.rsxml = RsXML()
Observable.__init__(self)
self.params = Parameters(**kwargs)
LOG.debug("ResourceSync initialized with the configuration provided.")
self._generator = None
self.set_generator(generator)
def get_generator(self):
return self._generator
def set_generator(self, generator):
if not generator:
return
assert isinstance(generator, Generator)
self._generator = generator
generator = property(get_generator, set_generator)
def execute(self):
executor = None
if self.params.strategy == Strategy.resourcelist:
executor = ResourceListExecutor(parameters=self.params)
elif self.params.strategy == Strategy.resourcedump:
executor = ResourceDumpExecutor(parameters=self.params)
elif self.params.strategy == Strategy.new_changelist:
executor = NewChangeListExecutor(parameters=self.params)
elif self.params.strategy == Strategy.inc_changelist:
executor = IncrementalChangeListExecutor(parameters=self.params)
elif self.params.strategy == Strategy.changedump:
executor = ChangeDumpExecutor(parameters=self.params)
else:
raise NotImplementedError("Strategy %s not implemented" %
self.params.strategy)
LOG.debug("Found executor for the strategy %s." % self.params.strategy)
LOG.debug("Obtaining list of resource metadata from the generator.")
resource_metadata = self.get_resource_list()
if executor:
executor.execute(resource_metadata)
self.params.save_configuration(True)
def get_resource_list(self):
if not self.generator:
raise ValueError("No generator found.")
resource_metadata = self.generator.generate()
if not resource_metadata:
# is returning no metadata an error?
LOG.warning(
"Generator returned an empty list of resource metadata")
return
return resource_metadata
def test_document_root(self):
params = Parameters(document_root="/var/www/html")
self.assert_params(params)
with self.assertRaises(ValueError):
Parameters(document_root="")
def test_is_saving_pretty_xml(self):
Parameters(is_saving_pretty_xml=True)
with self.assertRaises(TypeError):
Parameters(is_saving_pretty_xml="fff")
def test_is_saving_sitemaps(self):
Parameters(is_saving_sitemaps=True)
with self.assertRaises(TypeError):
Parameters(is_saving_sitemaps=111)
def test_has_wellknown_at_root(self):
Parameters(has_wellknown_at_root=True)
with self.assertRaises(TypeError):
Parameters(has_wellknown_at_root="asssssfasfda")
def test_defaults(self):
params = Parameters()
self.assert_params(params)
def test_constructor(self):
params = Parameters()
gen = Generator(params=params)
assert isinstance(gen, Generator)
with self.assertRaises(NotImplementedError):
gen.generate()
