def setUp(self):
super().setUp()
self.init_data()
self.app.data.insert('users', self.users)
self.app.data.insert('desks', self.desks)
self.app.data.insert('products', self.products)
self.app.data.insert('subscribers', self.subscribers)
self.app.data.insert(ARCHIVE, self.articles)
self.filename = os.path.join(os.path.abspath(os.path.dirname(__file__)), "validators.json")
self.json_data = [
{"_id": "kill_text", "act": "kill", "type": "text", "schema": {"headline": {"type": "string"}}},
{"_id": "publish_text", "act": "publish", "type": "text", "schema": {}},
{"_id": "correct_text", "act": "correct", "type": "text", "schema": {}},
{"_id": "publish_composite", "act": "publish", "type": "composite", "schema": {}},
]
self.article_versions = self._init_article_versions()
with open(self.filename, "w+") as file:
json.dump(self.json_data, file)
init_app(self.app)
ValidatorsPopulateCommand().run(self.filename)
self.app.media.url_for_media = MagicMock(return_value='url_for_media')
self.app.media.put = MagicMock(return_value='media_id')
def test_maintain_latest_version_for_published(self):
def get_publish_items(item_id, last_version):
query = {
'query': {
'filtered': {
'filter': {
'and': [{
'term': {
'item_id': item_id
}
}, {
'term': {
LAST_PUBLISHED_VERSION: last_version
}
}]
}
}
}
}
request = ParsedRequest()
request.args = {'source': json.dumps(query)}
return self.app.data.find(PUBLISHED, req=request, lookup=None)
ValidatorsPopulateCommand().run(self.filename)
get_resource_service(ARCHIVE).patch(
id=self.articles[1][config.ID_FIELD],
updates={'publish_schedule': None})
doc = get_resource_service(ARCHIVE).find_one(
req=None, _id=self.articles[1][config.ID_FIELD])
get_resource_service(ARCHIVE_PUBLISH).patch(
id=doc[config.ID_FIELD],
updates={ITEM_STATE: CONTENT_STATE.PUBLISHED})
queue_items = self.app.data.find(PUBLISH_QUEUE, None, None)
self.assertEqual(7, queue_items.count())
published_items = self.app.data.find(PUBLISHED, None, None)
self.assertEqual(2, published_items.count())
published_digital_doc = next(
(item for item in published_items
if item.get(PACKAGE_TYPE) == TAKES_PACKAGE), None)
published_doc = next((item for item in published_items
if item.get('item_id') == doc[config.ID_FIELD]),
None)
self.assertEqual(published_doc[LAST_PUBLISHED_VERSION], True)
self.assertEqual(published_digital_doc[LAST_PUBLISHED_VERSION], True)
get_resource_service(ARCHIVE_CORRECT).patch(
id=doc[config.ID_FIELD],
updates={ITEM_STATE: CONTENT_STATE.CORRECTED})
queue_items = self.app.data.find(PUBLISH_QUEUE, None, None)
self.assertEqual(14, queue_items.count())
published_items = self.app.data.find(PUBLISHED, None, None)
self.assertEqual(4, published_items.count())
last_published_digital = get_publish_items(
published_digital_doc['item_id'], True)
self.assertEqual(1, last_published_digital.count())
last_published = get_publish_items(published_doc['item_id'], True)
self.assertEqual(1, last_published.count())
def test_targeted_for_includes_digital_subscribers(self):
ValidatorsPopulateCommand().run(self.filename)
updates = {'target_regions': [{'qcode': 'NSW', 'name': 'New South Wales', 'allow': True}]}
doc_id = self.articles[9][config.ID_FIELD]
get_resource_service(ARCHIVE).patch(id=doc_id, updates=updates)
get_resource_service(ARCHIVE_PUBLISH).patch(id=doc_id, updates={ITEM_STATE: CONTENT_STATE.PUBLISHED})
enqueue_published()
queue_items = self.app.data.find(PUBLISH_QUEUE, None, None)
self.assertEqual(7, queue_items.count())
expected_subscribers = ['1', '2', '3', '4', '5']
for item in queue_items:
self.assertIn(item["subscriber_id"], expected_subscribers, 'item {}'.format(item))
def setUp(self):
super().setUp()
self._init_data()
self.app.data.insert('users', self.users)
self.app.data.insert('desks', self.desks)
self.app.data.insert('vocabularies', self.vocabularies)
self.app.data.insert('subscribers', self.subscribers)
self.app.data.insert(ARCHIVE, self.articles)
self.filename = os.path.join(
os.path.abspath(os.path.dirname(__file__)), "validators.json")
self.json_data = [
{
"_id": "kill_text",
"act": "kill",
"type": "text",
"schema": {
"headline": {
"type": "string"
}
}
},
{
"_id": "publish_text",
"act": "publish",
"type": "text",
"schema": {}
},
{
"_id": "correct_text",
"act": "correct",
"type": "text",
"schema": {}
},
{
"_id": "publish_composite",
"act": "publish",
"type": "composite",
"schema": {}
},
]
with open(self.filename, "w+") as file:
json.dump(self.json_data, file)
init_app(self.app)
ValidatorsPopulateCommand().run(self.filename)
self.package_service = PackageService()
def test_targeted_for_excludes_digital_subscribers(self):
ValidatorsPopulateCommand().run(self.filename)
updates = {
'targeted_for': [{
'name': 'New South Wales',
'allow': True
}]
}
doc_id = self.articles[9][config.ID_FIELD]
get_resource_service(ARCHIVE).patch(id=doc_id, updates=updates)
get_resource_service(ARCHIVE_PUBLISH).patch(
id=doc_id, updates={ITEM_STATE: CONTENT_STATE.PUBLISHED})
queue_items = self.app.data.find(PUBLISH_QUEUE, None, None)
self.assertEqual(4, queue_items.count())
expected_subscribers = ['1', '2']
self.assertIn(queue_items[0]["subscriber_id"], expected_subscribers)
self.assertIn(queue_items[1]["subscriber_id"], expected_subscribers)
self.assertIn(queue_items[2]["subscriber_id"], expected_subscribers)
def test_remove_published_and_killed_content_separately(self):
cmd = ValidatorsPopulateCommand()
with self.app.app_context():
cmd.run(self.filename)
self.app.data.insert('archive_versions', self.article_versions)
published_service = get_resource_service('published')
text_archive = get_resource_service('text_archive')
# Publishing an Article
doc = self.articles[7]
original = doc.copy()
get_resource_service('archive_publish').patch(id=doc['_id'], updates={config.CONTENT_STATE: 'published'})
published_items = published_service.get_other_published_items(original[config.ID_FIELD])
self.assertEqual(1, published_items.count())
article_in_production = get_resource_service(ARCHIVE).find_one(req=None, _id=original[config.ID_FIELD])
self.assertIsNotNone(article_in_production)
self.assertEqual(article_in_production[config.CONTENT_STATE], 'published')
self.assertEqual(article_in_production[config.VERSION], original[config.VERSION] + 1)
insert_into_versions(doc=article_in_production)
# Setting the expiry date of the published article to 1 hr back from now
published_service.update_published_items(
original[config.ID_FIELD], 'expiry', utcnow() + timedelta(minutes=-60))
# Killing the published article and manually inserting the version of the article as unittests use
# service directly
get_resource_service('archive_kill').patch(id=doc['_id'], updates={config.CONTENT_STATE: 'killed'})
# Executing the Expiry Job for the Published Article and asserting the collections
RemoveExpiredPublishContent().run()
articles_in_text_archive = text_archive.get(req=None, lookup={'item_id': original[config.ID_FIELD]})
self.assertEqual(articles_in_text_archive.count(), 0)
published_items = published_service.get_other_published_items(str(original[config.ID_FIELD]))
self.assertEqual(1, published_items.count())
article_in_production = get_resource_service(ARCHIVE).find_one(req=None, _id=original[config.ID_FIELD])
self.assertIsNotNone(article_in_production)
self.assertEqual(article_in_production[config.CONTENT_STATE], 'killed')
self.assertEqual(article_in_production[config.VERSION], original[config.VERSION] + 2)
insert_into_versions(doc=article_in_production)
# Validate the collections in Legal Archive
article_in_legal_archive, article_versions_in_legal_archive, queue_items = \
self._get_legal_archive_details(original[config.ID_FIELD])
self.assertIsNotNone(article_in_legal_archive, 'Article cannot be none in Legal Archive')
self.assertEqual(article_in_legal_archive[config.CONTENT_STATE], 'published')
self.assertIsNotNone(article_versions_in_legal_archive, 'Article Versions cannot be none in Legal Archive')
self.assertEqual(article_versions_in_legal_archive.count(), 5)
self.assertGreaterEqual(queue_items.count(), 1, 'Publish Queue Items must be greater than or equal to 1')
# Setting the expiry date of the killed article to 1 hr back from now and running the job again
published_service.update_published_items(
original[config.ID_FIELD], 'expiry', utcnow() + timedelta(minutes=-60))
RemoveExpiredPublishContent().run()
articles_in_text_archive = text_archive.get(req=None, lookup={'item_id': original[config.ID_FIELD]})
self.assertEqual(articles_in_text_archive.count(), 0)
published_items = published_service.get_other_published_items(str(original[config.ID_FIELD]))
self.assertEqual(0, published_items.count())
article_in_production = get_resource_service(ARCHIVE).find_one(req=None, _id=original[config.ID_FIELD])
self.assertIsNone(article_in_production)
# Validate the collections in Legal Archive
article_in_legal_archive, article_versions_in_legal_archive, queue_items = \
self._get_legal_archive_details(original[config.ID_FIELD], publishing_action='killed')
self.assertIsNotNone(article_in_legal_archive, 'Article cannot be none in Legal Archive')
self.assertEqual(article_in_legal_archive['state'], 'killed')
self.assertIsNotNone(article_versions_in_legal_archive, 'Article Versions cannot be none in Legal Archive')
self.assertEqual(article_versions_in_legal_archive.count(), 6)
for queue_item in queue_items:
self.assertEqual(queue_item['item_id'], original[config.ID_FIELD])
self.assertEqual(queue_item['item_version'], original[config.VERSION] + 2)
self.assertGreaterEqual(queue_items.count(), 1, 'Publish Queue Items must be greater than or equal to 1')
def test_remove_expired_published_and_killed_content(self):
cmd = ValidatorsPopulateCommand()
with self.app.app_context():
cmd.run(self.filename)
self.app.data.insert('archive_versions', self.article_versions)
published_service = get_resource_service('published')
text_archive = get_resource_service('text_archive')
# Publishing an Article
doc = self.articles[0]
original = doc.copy()
get_resource_service('archive_publish').queue_transmission(original)
published_service.post([original])
published_items = published_service.get_other_published_items(original['item_id'])
self.assertEquals(1, published_items.count())
# Setting the expiry date of the published article to 1 hr back from now
published_service.update_published_items(original['item_id'], 'expiry', utcnow() + timedelta(minutes=-60))
# Killing the published article and manually inserting the version of the article as unittests use
# service directly
_current_version = doc[config.VERSION] + 1
get_resource_service('archive_kill').patch(id=doc['_id'],
updates={config.VERSION: _current_version})
killed_version = {
'guid': 'tag:localhost:2015:69b961ab-2816-4b8a-a584-a7b402fed4f9',
versioned_id_field(): '1',
'type': 'text',
config.VERSION: _current_version,
'body_html': 'Test body',
'destination_groups': ['4'],
'urgency': 4,
'headline': 'Two students missing',
'pubstatus': 'usable',
'firstcreated': utcnow(),
'byline': 'By Alan Karben',
'ednote': 'Andrew Marwood contributed to this article',
'dateline': 'Sydney',
'keywords': ['Student', 'Crime', 'Police', 'Missing'],
'subject': [{'qcode': '17004000', 'name': 'Statistics'}, {'qcode': '04001002', 'name': 'Weather'}],
'state': 'published',
'expiry': utcnow() + timedelta(minutes=20),
'unique_name': '#2'
}
self.app.data.insert('archive_versions', [killed_version])
# Executing the Expiry Job for the Published Article and asserting the collections
RemoveExpiredPublishContent().run()
articles_in_text_archive = text_archive.get(req=None, lookup={'item_id': original['item_id']})
self.assertEquals(articles_in_text_archive.count(), 0)
published_items = published_service.get_other_published_items(str(original['item_id']))
self.assertEquals(1, published_items.count())
article_in_production = get_resource_service(ARCHIVE).find_one(req=None, _id=original['item_id'])
self.assertIsNotNone(article_in_production)
self.assertEquals(article_in_production['state'], 'killed')
self.assertEquals(article_in_production[config.VERSION], _current_version)
# Validate the collections in Legal Archive
article_in_legal_archive, article_versions_in_legal_archive, formatted_items, queue_items = \
self.__get_legal_archive_details(original['item_id'])
self.assertIsNotNone(article_in_legal_archive, 'Article cannot be none in Legal Archive')
self.assertEquals(article_in_legal_archive['state'], 'published')
self.assertIsNotNone(article_versions_in_legal_archive, 'Article Versions cannot be none in Legal Archive')
self.assertEquals(article_versions_in_legal_archive.count(), 4)
self.assertGreaterEqual(formatted_items.count(), 1, 'Formatted Items must be greater than or equal to 1')
for formatted_item in formatted_items:
self.assertEquals(formatted_item['item_id'], original['item_id'])
self.assertEquals(formatted_item['item_version'], self.articles[0][config.VERSION])
self.assertGreaterEqual(queue_items.count(), 1, 'Publish Queue Items must be greater than or equal to 1')
# Setting the expiry date of the killed article to 1 hr back from now and running the job again
published_service.update_published_items(original['item_id'], 'expiry', utcnow() + timedelta(minutes=-60))
RemoveExpiredPublishContent().run()
articles_in_text_archive = text_archive.get(req=None, lookup={'item_id': original['item_id']})
self.assertEquals(articles_in_text_archive.count(), 0)
published_items = published_service.get_other_published_items(str(original['item_id']))
self.assertEquals(0, published_items.count())
article_in_production = get_resource_service(ARCHIVE).find_one(req=None, _id=original['item_id'])
self.assertIsNone(article_in_production)
# Validate the collections in Legal Archive
article_in_legal_archive, article_versions_in_legal_archive, formatted_items, queue_items = \
self.__get_legal_archive_details(original['item_id'], article_version=_current_version,
publishing_action='killed')
self.assertIsNotNone(article_in_legal_archive, 'Article cannot be none in Legal Archive')
self.assertEquals(article_in_legal_archive['state'], 'killed')
self.assertIsNotNone(article_versions_in_legal_archive, 'Article Versions cannot be none in Legal Archive')
self.assertEquals(article_versions_in_legal_archive.count(), 5)
self.assertGreaterEqual(formatted_items.count(), 1, 'Formatted Items must be greater than or equal to 1')
for formatted_item in formatted_items:
self.assertEquals(formatted_item['item_id'], original['item_id'])
self.assertEquals(formatted_item['item_version'], _current_version)
self.assertGreaterEqual(queue_items.count(), 1, 'Publish Queue Items must be greater than or equal to 1')