def test_index_updates_on_import(self): """ Verifies that the index is correctly updated when importing a resource. """ self.assert_index_is_empty() # import a single resource and save it in the DB resource = test_utils.import_xml(SearchIndexUpdateTests.RES_PATH_1)[0] resource.storage_object.publication_status = INGESTED resource.storage_object.save() # make sure the import has automatically changed the search index self.assertEqual( SearchQuerySet().count(), 1, "After the import of a resource the index must automatically " "have changed and contain that resource.", ) # import another resource and save it in the DB resource = test_utils.import_xml(SearchIndexUpdateTests.RES_PATH_2)[0] resource.storage_object.publication_status = INGESTED resource.storage_object.save() # make sure the import has automatically changed the search index self.assertEqual( SearchQuerySet().count(), 2, "After the import of a resource the index must automatically " "have changed and contain that resource.", )
def setUp(self): """ Imports a few test resources. """ test_utils.setup_test_storage() self.test_res_1 = test_utils.import_xml("{0}/repository/fixtures/testfixture.xml".format(ROOT_PATH)) self.test_res_2 = test_utils.import_xml("{0}/repository/fixtures/ILSP10.xml".format(ROOT_PATH))
def setUpClass(cls): """ Import a resource to test the workflow changes for """ LOGGER.info("running '{}' tests...".format(cls.__name__)) test_utils.set_index_active(False) test_utils.setup_test_storage() _test_editor_group = \ EditorGroup.objects.create(name='test_editor_group') _test_manager_group = \ EditorGroupManagers.objects.create(name='test_manager_group', managed_group=_test_editor_group) owner = test_utils.create_manager_user( 'manageruser', '*****@*****.**', 'secret', (_test_editor_group, _test_manager_group)) # load first resource _fixture = '{0}/repository/fixtures/testfixture.xml'.format(ROOT_PATH) _result = test_utils.import_xml(_fixture) _result.editor_groups.add(_test_editor_group) _result.owners.add(owner) # load second resource _fixture = '{0}/repository/test_fixtures/ingested-corpus-AudioVideo-French.xml'.format( ROOT_PATH) _result = test_utils.import_xml(_fixture) _result.editor_groups.add(_test_editor_group) _result.owners.add(owner) # create a normal user test_utils.create_user('user', '*****@*****.**', 'mypasswd')
def setUp(self): """ Import a resource to test the workflow changes for """ test_utils.set_index_active(False) test_utils.setup_test_storage() # create Groups trgroup = Group.objects.create(name="technicalReviewers") ecgroup = Group.objects.create(name='ecmembers') owner = User.objects.create_user('ecuser', '*****@*****.**', 'secret') owner.groups.add(ecgroup) owner.is_staff = True owner.save() # create a superuser su = User.objects.create_user('su', '*****@*****.**', 'supwd') su.is_superuser = True su.is_staff = True su.save() # load first resource _fixture = '{0}/repository/fixtures/testfixture.xml'.format(ROOT_PATH) _result = test_utils.import_xml(_fixture) _result.owners.add(su) # load second resource _fixture = '{0}/repository/test_fixtures/ingested-corpus-text-French.xml'.format( ROOT_PATH) _result = test_utils.import_xml(_fixture) _result.owners.add(su)
def setUpClass(cls): """ Import a resource to test the workflow changes for """ LOGGER.info("running '{}' tests...".format(cls.__name__)) test_utils.set_index_active(False) test_utils.setup_test_storage() _test_editor_group = \ EditorGroup.objects.create(name='test_editor_group') _test_manager_group = \ EditorGroupManagers.objects.create(name='test_manager_group', managed_group=_test_editor_group) owner = test_utils.create_manager_user( 'manageruser', '*****@*****.**', 'secret', (_test_editor_group, _test_manager_group)) # load first resource _fixture = '{0}/repository/fixtures/testfixture.xml'.format(ROOT_PATH) _result = test_utils.import_xml(_fixture) _result.editor_groups.add(_test_editor_group) _result.owners.add(owner) # load second resource _fixture = '{0}/repository/test_fixtures/ingested-corpus-AudioVideo-French.xml'.format(ROOT_PATH) _result = test_utils.import_xml(_fixture) _result.editor_groups.add(_test_editor_group) _result.owners.add(owner) # create a normal user test_utils.create_user('user', '*****@*****.**', 'mypasswd')
def setUp(self): """ Imports a few test resources. """ self.test_res_1 = test_utils.import_xml( '{0}/repository/fixtures/testfixture.xml'.format(ROOT_PATH))[0] self.test_res_2 = test_utils.import_xml( '{0}/repository/fixtures/ILSP10.xml'.format(ROOT_PATH))[0]
def setUp(self): """ Imports a few test resources. """ test_utils.setup_test_storage() self.test_res_1 = test_utils.import_xml( '{0}/repository/fixtures/testfixture.xml'.format(ROOT_PATH)) self.test_res_2 = test_utils.import_xml( '{0}/repository/fixtures/ILSP10.xml'.format(ROOT_PATH))
def setUp(self): test_utils.setup_test_storage() _fixture = '{0}/repository/fixtures/testfixture.xml'.format(ROOT_PATH) _result = test_utils.import_xml(_fixture) self.resource_id = _result[0].id resource = resourceInfoType_model.objects.get(pk=self.resource_id) resource.storage_object.published = True resource.storage_object.save() # set up test users with and without staff permissions. # These will live in the test database only, so will not # pollute the "normal" development db or the production db. # As a consequence, they need no valuable password. staffuser = User.objects.create_user('staffuser', '*****@*****.**', 'secret') staffuser.is_staff = True staffuser.save() User.objects.create_user('normaluser', '*****@*****.**', 'secret') # init Selenium driver = getattr(webdriver, settings.SELENIUM_DRIVER, None) assert driver, "settings.SELENIUM_DRIVER contains non-existing driver" self.driver = driver() self.driver.implicitly_wait(30) host = getattr(settings, 'SELENIUM_TESTSERVER_HOST', 'localhost') port = getattr(settings, 'SELENIUM_TESTSERVER_PORT', 8011) self.base_url = 'http://{0}:{1}/{2}'.format(host, port, DJANGO_BASE) self.verification_errors = []
def test_case_insensitive_search(self): """ Asserts that case-insensitive searching is done. """ imported_res = test_utils.import_xml( "{}/repository/test_fixtures/" "internal-corpus-Text-EngPers.xml".format(ROOT_PATH) )[0] imported_res.storage_object.published = True imported_res.storage_object.save() client = Client() # assert that a lower case search for an upper case term succeeds: response = client.get("/{0}repository/search/".format(DJANGO_BASE), follow=True, data={"q": "fixture"}) self.assertEqual("repository/search.html", response.templates[0].name) self.assertContains(response, "1 Language Resource", status_code=200) # assert that an upper case search for a lower case term succeeds: response = client.get("/{0}repository/search/".format(DJANGO_BASE), follow=True, data={"q": "ORIGINALLY"}) self.assertEqual("repository/search.html", response.templates[0].name) self.assertContains(response, "1 Language Resource", status_code=200) # assert that a lower case search for a mixed case term succeeds: response = client.get("/{0}repository/search/".format(DJANGO_BASE), follow=True, data={"q": "unicode"}) self.assertEqual("repository/search.html", response.templates[0].name) self.assertContains(response, "1 Language Resource", status_code=200) # assert that a mixed case search for an upper case term succeeds: response = client.get("/{0}repository/search/".format(DJANGO_BASE), follow=True, data={"q": "FiXTuRe"}) self.assertEqual("repository/search.html", response.templates[0].name) self.assertContains(response, "1 Language Resource", status_code=200) # assert that a camelCase search for an upper case term succeeds: response = client.get("/{0}repository/search/".format(DJANGO_BASE), follow=True, data={"q": "fixTure"}) self.assertEqual("repository/search.html", response.templates[0].name) self.assertContains(response, "1 Language Resource", status_code=200) # assert that an all lower case search finds a camelCase term: response = client.get("/{0}repository/search/".format(DJANGO_BASE), follow=True, data={"q": "speechsynthesis"}) self.assertEqual("repository/search.html", response.templates[0].name) self.assertContains(response, "1 Language Resource", status_code=200)
def testRollbackOnImportError(self): """ Checks that a complete rollback is performed on import error. """ _database = {} _models = [x for x in dir(sys.modules['metashare.repository.models']) if x.endswith('_model')] for _model in _models: if hasattr(sys.modules['metashare.repository.models'], _model): _inst = getattr(sys.modules['metashare.repository.models'], _model) _database[_model] = _inst.objects.count() _broken_fixture = '{0}/repository/fixtures/broken.xml'.format(ROOT_PATH) result = test_utils.import_xml(_broken_fixture) self.assertEqual(result[:2], (None, [])) errors = [] for _model in _models: if hasattr(sys.modules['metashare.repository.models'], _model): _inst = getattr(sys.modules['metashare.repository.models'], _model) print "Testing rollback for {}...".format(_model) if _database[_model] != _inst.objects.count(): errors.append(_model) self.assertEqual(errors, [])
def test_download_count_visible_and_updated_in_search_results(self): """ Verifies that the download count of a resource is visible and updated in the search results list. """ test_res = test_utils.import_xml('{}/repository/fixtures/' 'downloadable_1_license.xml'.format(ROOT_PATH)) test_res.storage_object.published = True test_res.storage_object.save() client = Client() client.login(username='******', password='******') # to be on the safe side, clear any existing stats LRStats.objects.all().delete() # assert that the download/view counts are both zero at first: response = client.get(_SEARCH_PAGE_PATH) self.assertContains(response, 'title="Number of downloads" /> 0') self.assertContains(response, 'title="Number of views" /> 0') # view the resource, download it, go back to the browse page and then # assert that both view and download counts have changed: client.get(test_res.get_absolute_url()) client.post( reverse(views.download, args=(test_res.storage_object.identifier,)), { 'in_licence_agree_form': 'True', 'licence_agree': 'True', 'licence': 'CC-BY-NC-SA' }) response = client.get(_SEARCH_PAGE_PATH) self.assertContains(response, 'title="Number of downloads" /> 1') self.assertContains(response, 'title="Number of views" /> 1')
def test_cannot_change_publication_status_of_remote_copies(self): # not even a superuser must change the publication status of a remote # resource copy superuser = User.objects.create_superuser( "superuser", "*****@*****.**", "secret") client = Client() client.login(username=superuser.username, password='******') # import a temporary resource to not mess with the other tests and set # the copy status to remote resource = test_utils.import_xml( '{0}/repository/fixtures/ILSP10.xml'.format(ROOT_PATH)) resource.storage_object.copy_status = REMOTE # (1) verify that a status change from published is not possible: resource.storage_object.publication_status = PUBLISHED resource.storage_object.save() client.post(ADMINROOT, {"action": "unpublish_action", ACTION_CHECKBOX_NAME: resource.id}, follow=True) # fetch the resource from DB as our object is not up-to-date anymore resource = resourceInfoType_model.objects.get(pk=resource.id) self.assertEquals('published', resource.publication_status()) # (2) verify that a status change from ingested is not possible: resource.storage_object.publication_status = INGESTED resource.storage_object.save() client.post(ADMINROOT, {"action": "publish_action", ACTION_CHECKBOX_NAME: resource.id}, follow=True) # fetch the resource from DB as our object is not up-to-date anymore resource = resourceInfoType_model.objects.get(pk=resource.id) self.assertEquals('ingested', resource.publication_status())
def test_cannot_change_publication_status_of_remote_copies(self): # not even a superuser must change the publication status of a remote # resource copy superuser = User.objects.create_superuser("superuser", "*****@*****.**", "secret") client = Client() client.login(username=superuser.username, password='******') # import a temporary resource to not mess with the other tests and set # the copy status to remote resource = test_utils.import_xml( '{0}/repository/fixtures/ILSP10.xml'.format(ROOT_PATH)) resource.storage_object.copy_status = REMOTE # (1) verify that a status change from published is not possible: resource.storage_object.publication_status = PUBLISHED resource.storage_object.save() client.post(ADMINROOT, { "action": "unpublish_action", ACTION_CHECKBOX_NAME: resource.id }, follow=True) # fetch the resource from DB as our object is not up-to-date anymore resource = resourceInfoType_model.objects.get(pk=resource.id) self.assertEquals('published', resource.publication_status()) # (2) verify that a status change from ingested is not possible: resource.storage_object.publication_status = INGESTED resource.storage_object.save() client.post(ADMINROOT, { "action": "publish_action", ACTION_CHECKBOX_NAME: resource.id }, follow=True) # fetch the resource from DB as our object is not up-to-date anymore resource = resourceInfoType_model.objects.get(pk=resource.id) self.assertEquals('ingested', resource.publication_status())
def test_view_count_visible_and_updated_in_search_results(self): """ Verifies that the view count of a resource is visible and updated in the search results list. """ test_res = test_utils.import_xml( '{}/repository/test_fixtures/' 'internal-corpus-Text-EngPers.xml'.format(ROOT_PATH)) test_res.storage_object.published = True test_res.storage_object.save() client = Client() # to be on the safe side, clear any existing stats LRStats.objects.all().delete() # assert that the download/view counts are both zero at first: response = client.get(_SEARCH_PAGE_PATH) self.assertContains(response, 'title="Number of downloads" /> 0') self.assertContains(response, 'title="Number of views" /> 0') # view the resource, then go back to the browse page and assert that the # view count has changed: client.get(test_res.get_absolute_url()) response = client.get(_SEARCH_PAGE_PATH) self.assertContains(response, 'title="Number of downloads" /> 0') self.assertContains(response, 'title="Number of views" /> 1') # log in, view the resource again, go back to the browse page and then # assert that the view count has changed again: client.login(username='******', password='******') client.get(test_res.get_absolute_url()) response = client.get(_SEARCH_PAGE_PATH) self.assertContains(response, 'title="Number of downloads" /> 0') self.assertContains(response, 'title="Number of views" /> 2')
def test_view_count_visible_and_updated_in_search_results(self): """ Verifies that the view count of a resource is visible and updated in the search results list. """ test_res = test_utils.import_xml('{}/repository/test_fixtures/' 'internal-corpus-Text-EngPers.xml'.format(ROOT_PATH)) test_res.storage_object.published = True test_res.storage_object.save() client = Client() # to be on the safe side, clear any existing stats LRStats.objects.all().delete() # assert that the download/view counts are both zero at first: response = client.get(_SEARCH_PAGE_PATH) self.assertContains(response, 'title="Number of downloads" /> 0') self.assertContains(response, 'title="Number of views" /> 0') # view the resource, then go back to the browse page and assert that the # view count has changed: client.get(test_res.get_absolute_url()) response = client.get(_SEARCH_PAGE_PATH) self.assertContains(response, 'title="Number of downloads" /> 0') self.assertContains(response, 'title="Number of views" /> 1') # log in, view the resource again, go back to the browse page and then # assert that the view count has changed again: client.login(username='******', password='******') client.get(test_res.get_absolute_url()) response = client.get(_SEARCH_PAGE_PATH) self.assertContains(response, 'title="Number of downloads" /> 0') self.assertContains(response, 'title="Number of views" /> 2')
def import_test_resource(filename, publication_status, deleted=False): _fixture = '{0}/repository/fixtures/{1}'.format(settings.ROOT_PATH, filename) resource = test_utils.import_xml(_fixture) resource.storage_object.publication_status = publication_status resource.storage_object.deleted = deleted resource.storage_object.save() resource.storage_object.update_storage() return resource
def test_ingested_LRs_are_not_indexed(self): test_res = test_utils.import_xml('{}/repository/test_fixtures/ingested/' 'ingested-corpus-AudioVideo-French.xml'.format(ROOT_PATH)) test_res.storage_object.publication_status = INGESTED test_res.storage_object.save() response = Client().get(_SEARCH_PAGE_PATH, data={'q': 'INGESTED'}) self.assertTemplateUsed(response, 'repository/search.html') self.assertContains(response, "No results were found for search query")
def setUp(self): """ Set up the email test """ test_utils.setup_test_storage() _fixture = '{0}/repository/fixtures/testfixture.xml'.format(ROOT_PATH) _result = test_utils.import_xml(_fixture) self.resource_id = _result[0].id
def import_test_resource(cls, editor_group=None, path=TESTFIXTURE_XML): test_utils.setup_test_storage() result = test_utils.import_xml(path) resource = result[0] if not editor_group is None: resource.editor_groups.add(editor_group) resource.save() return resource
def setUp(self): """ Import a resource to test the workflow changes for """ test_utils.setup_test_storage() _fixture = '{0}/repo2/fixtures/testfixture.xml'.format(ROOT_PATH) _result = test_utils.import_xml(_fixture) self.resource_id = _result[0].id
def setUp(self): """ Set up the email test """ test_utils.setup_test_storage() _fixture = '{0}/repository/fixtures/testfixture.xml'.format(ROOT_PATH) _result = test_utils.import_xml(_fixture) self.resource_id = _result.id
def import_test_resource(cls, filename, status): test_utils.setup_test_storage() _fixture = '{0}/repository/fixtures/{1}'.format(settings.ROOT_PATH, filename) result = test_utils.import_xml(_fixture) resource = result[0] resource.storage_object.publication_status = status resource.storage_object.save() resource.storage_object.update_storage() return resource
def import_test_resource(cls, filename, pub_status, copy_status=MASTER, url=settings.DJANGO_URL): _fixture = '{0}/repository/fixtures/{1}'.format(settings.ROOT_PATH, filename) resource = test_utils.import_xml(_fixture) resource.storage_object.publication_status = pub_status resource.storage_object.copy_status = copy_status resource.storage_object.source_url = url resource.storage_object.save() resource.storage_object.update_storage() return resource
def setUp(self): """ Set up the email test """ test_utils.setup_test_storage() _fixture = '{0}/repository/fixtures/testfixture.xml'.format(ROOT_PATH) self.resource = test_utils.import_xml(_fixture) self.resource.storage_object.published = True self.resource.storage_object.save()
def _import_resource(fixture_name): """ Imports the XML resource description with the given file name. The new resource is published and returned. """ result = test_utils.import_xml('{0}/repository/fixtures/{1}' .format(ROOT_PATH, fixture_name))[0] result.storage_object.published = True result.storage_object.save() return result
def testImportELRA(self): """ run tests on ELRA resources """ _path = '{0}/../misc/testdata/ELRAResources/'.format(ROOT_PATH) _files = os.listdir(_path) for _file in _files: _currfile = "%s%s" % (_path, _file) _result = test_utils.import_xml(_currfile) self.assertNotEqual(_result[:2], (None, []))
def _import_resource(res_file_name): """ Imports the resource with the given file name; looks for the file in the folder recommendations/fixtures/; sets publication status to PUBLISHED; returns the resource """ res = test_utils.import_xml( '{0}/recommendations/fixtures/{1}'.format(ROOT_PATH, res_file_name)) res.storage_object.publication_status = PUBLISHED res.storage_object.save() res.storage_object.update_storage() return res
def import_test_resource(cls, filename, pub_status, \ copy_status=MASTER, url=settings.DJANGO_URL, source_node=None): _fixture = '{0}/repository/fixtures/{1}'.format( settings.ROOT_PATH, filename) resource = test_utils.import_xml(_fixture) resource.storage_object.publication_status = pub_status resource.storage_object.copy_status = copy_status resource.storage_object.source_url = url resource.storage_object.source_node = source_node resource.storage_object.save() resource.storage_object.update_storage() return resource
def test_index_updates_on_import(self): """ Verifies that the index is correctly updated when importing a resource. """ self.assert_index_is_empty() # import a single resource and save it in the DB resource = test_utils.import_xml(SearchIndexUpdateTests.RES_PATH_1) resource.storage_object.publication_status = PUBLISHED resource.storage_object.save() # make sure the import has automatically changed the search index self.assertEqual(SearchQuerySet().count(), 1, "After the import of a resource the index must automatically " \ "have changed and contain that resource.") # import another resource and save it in the DB resource = test_utils.import_xml(SearchIndexUpdateTests.RES_PATH_2) resource.storage_object.publication_status = PUBLISHED resource.storage_object.save() # make sure the import has automatically changed the search index self.assertEqual(SearchQuerySet().count(), 2, "After the import of a resource the index must automatically " \ "have changed and contain that resource.")
def test_status_after_saving(self): # load test fixture and set its status to 'published' test_utils.setup_test_storage() _result = test_utils.import_xml(TESTFIXTURE_XML) resource = resourceInfoType_model.objects.get(pk=_result[0].id) resource.editor_groups.add(self.test_editor_group) resource.storage_object.published = True # this also saves the storage object: resource.save() driver = self.driver driver.get(self.base_url) # login user login_user(driver, "manageruser", "secret") # make sure login was successful self.assertEqual("Logout", driver.find_element_by_xpath("//div[@id='inner']/div[2]/a[3]/div").text) # go to Editor driver.find_element_by_css_selector("div.button.middle_button").click() # go to Update->Resource mouse_over(driver, driver.find_element_by_link_text("Update")) #driver.find_element_by_link_text("Resource").click() click_menu_item(driver, driver.find_element_by_link_text("Resource")) # make sure we are on the right site self.assertEqual("Select Resource to change | META-SHARE backend", driver.title) # check if LR entry is available and that its status is published try: self.assertEqual("REVEAL-THIS Corpus", driver.find_element_by_link_text("REVEAL-THIS Corpus").text) except AssertionError as e: self.verification_errors.append(str(e)) try: self.assertEqual( "published", driver.find_element_by_xpath("//table[@id='result_list']/tbody/tr/td[3]").text) except AssertionError as e: self.verification_errors.append(str(e)) # click LR to edit it driver.find_element_by_link_text("REVEAL-THIS Corpus").click() # change the short name and save the LR driver.find_element_by_name("key_form-0-resourceShortName_0").clear() driver.find_element_by_name("key_form-0-resourceShortName_0").send_keys("en") driver.find_element_by_name("val_form-0-resourceShortName_0").clear() driver.find_element_by_name("val_form-0-resourceShortName_0").send_keys("a random short name") driver.find_element_by_name("_save").click() # make sure that the LR status is still published after saving try: self.assertEqual( "published", driver.find_element_by_xpath("//table[@id='result_list']/tbody/tr/td[3]").text) except AssertionError as e: self.verification_errors.append(str(e))
def _import_resource(fixture_name): """ Imports the XML resource description with the given file name. The new resource is published and the ID is returned. """ _result = test_utils.import_xml('{0}/repository/fixtures/{1}' .format(ROOT_PATH, fixture_name)) result = _result[0].id resource = resourceInfoType_model.objects.get(pk=result) resource.storage_object.published = True resource.storage_object.save() return result
def test_save_metadata(self): """ Tests that the metadata XML is not written to the storage folder for internal resources but only when the resource is ingested """ # load test fixture; its initial status is 'internal' _result = test_utils.import_xml(TESTFIXTURE_XML) resource = resourceInfoType_model.objects.get(pk=_result.id) _storage_object = resource.storage_object _storage_object.update_storage() # initial status is 'internal' self.assertTrue(_storage_object.publication_status == INTERNAL) # internal resource has no metadata XML stored in storage folder self.assertFalse( os.path.isfile('{0}/metadata-{1:04d}.xml'.format( _storage_object._storage_folder(), _storage_object.revision))) # set status to ingested _storage_object.publication_status = INGESTED _storage_object.update_storage() # ingested resource has metadata XML stored in storage folder self.assertTrue( os.path.isfile('{0}/metadata-{1:04d}.xml'.format( _storage_object._storage_folder(), _storage_object.revision))) # ingested resource has global part of storage object in storage folder self.assertTrue( os.path.isfile('{0}/storage-global.json'.format( _storage_object._storage_folder()))) # ingested resource has local part of storage object in storage folder self.assertTrue( os.path.isfile('{0}/storage-local.json'.format( _storage_object._storage_folder()))) # ingested resource has digest zip in storage folder self.assertTrue( os.path.isfile('{0}/resource.zip'.format( _storage_object._storage_folder()))) # digest zip contains metadata.xml and storage-global.json _zf_name = '{0}/resource.zip'.format( _storage_object._storage_folder()) _zf = zipfile.ZipFile(_zf_name, mode='r') self.assertTrue('metadata.xml' in _zf.namelist()) self.assertTrue('storage-global.json' in _zf.namelist()) # md5 of digest zip is stored in storage object with ZipFile(_zf_name, 'r') as inzip: with inzip.open('metadata.xml') as resource_xml: resource_xml_string = resource_xml.read() with inzip.open('storage-global.json') as storage_file: # read json string storage_json_string = storage_file.read() _checksum = compute_digest_checksum( resource_xml_string, storage_json_string) self.assertEqual(_checksum, _storage_object.digest_checksum)
def _import_resource(fixture_name, editor_group=None): """ Imports the XML resource description with the given file name. The new resource is published and returned. """ result = test_utils.import_xml('{0}/repository/fixtures/{1}' .format(ROOT_PATH, fixture_name)) result.storage_object.published = True if not editor_group is None: result.editor_groups.add(editor_group) result.save() result.storage_object.save() return result
def test_sitemap(self): """ Tests the correct appearance of the sitemap """ imported_res = test_utils.import_xml("{}/repository/fixtures/" "testfixture.xml".format(ROOT_PATH)) imported_res.storage_object.published = True imported_res.storage_object.save() client = Client() # Assert that the sitemap page contains the xmlsn and the entry # of the imported resource. response = client.get(SITEMAP_URL) self.assertEqual(response.status_code, 200) self.assertContains(response, '<urlset xmlns="http://www.sitemaps.org/schemas/sitemap/0.9">') self.assertContains(response, "{}/repository/browse/italian-tts-speech-corpus-appen/".format(DJANGO_URL))
def init_index_with_a_resource(self): """ Initializes an empty search index with a single resource. The imported resource is returned. Asserts that the index really only contains a single resource. """ self.assert_index_is_empty() # import a single resource and save it in the DB resource = test_utils.import_xml(SearchIndexUpdateTests.RES_PATH_1)[0] resource.storage_object.save() # make sure the import has automatically changed the search index self.assertEqual(SearchQuerySet().count(), 1, "After the import of a resource the index must automatically " \ "have changed and contain that resource.") return resource
def test_case_insensitive_search(self): """ Asserts that case-insensitive searching is done. """ imported_res = test_utils.import_xml( '{}/repository/test_fixtures/' 'internal-corpus-Text-EngPers.xml'.format(ROOT_PATH)) imported_res.storage_object.published = True imported_res.storage_object.save() client = Client() # assert that a lower case search for an upper case term succeeds: response = client.get(_SEARCH_PAGE_PATH, follow=True, data={'q': 'fixture'}) self.assertEqual('repository/search.html', response.templates[0].name) self.assertContains(response, "1 Language Resource", status_code=200) # assert that an upper case search for a lower case term succeeds: response = client.get(_SEARCH_PAGE_PATH, follow=True, data={'q': 'ORIGINALLY'}) self.assertEqual('repository/search.html', response.templates[0].name) self.assertContains(response, "1 Language Resource", status_code=200) # assert that a lower case search for a mixed case term succeeds: response = client.get(_SEARCH_PAGE_PATH, follow=True, data={'q': 'unicode'}) self.assertEqual('repository/search.html', response.templates[0].name) self.assertContains(response, "1 Language Resource", status_code=200) # assert that a mixed case search for an upper case term succeeds: response = client.get(_SEARCH_PAGE_PATH, follow=True, data={'q': 'FiXTuRe'}) self.assertEqual('repository/search.html', response.templates[0].name) self.assertContains(response, "1 Language Resource", status_code=200) # assert that a camelCase search for an upper case term succeeds: response = client.get(_SEARCH_PAGE_PATH, follow=True, data={'q': 'fixTure'}) self.assertEqual('repository/search.html', response.templates[0].name) self.assertContains(response, "1 Language Resource", status_code=200) # assert that an all lower case search finds a camelCase term: response = client.get(_SEARCH_PAGE_PATH, follow=True, data={'q': 'camelcasetest'}) self.assertEqual('repository/search.html', response.templates[0].name) self.assertContains(response, "1 Language Resource", status_code=200)
def init_index_with_a_resource(self): """ Initializes an empty search index with a single resource. The imported resource is returned. Asserts that the index really only contains a single resource. """ self.assert_index_is_empty() # import a single resource and save it in the DB resource = test_utils.import_xml(SearchIndexUpdateTests.RES_PATH_1) resource.storage_object.publication_status = PUBLISHED resource.storage_object.save() # make sure the import has automatically changed the search index self.assertEqual(SearchQuerySet().count(), 1, "After the import of a resource the index must automatically " \ "have changed and contain that resource.") return resource
def assert_import_equals_export(self, _roundtrip): _result = test_utils.import_xml(_roundtrip) with open(_roundtrip) as _import_file: _import_xml = _import_file.read() register_namespace("", SCHEMA_NAMESPACE) _import_xml = to_xml_string(fromstring(_import_xml), encoding="utf-8") _export_xml = to_xml_string(_result.export_to_elementtree(), encoding="utf-8") # cfedermann: uncomment these lines to dump import/export XML to file. # # with open('/tmp/_import.xml', 'wb') as _out: # _out.write(_import_xml.encode('utf-8')) # with open('/tmp/_export.xml', 'wb') as _out: # _out.write(_export_xml.encode('utf-8')) diff = "\n".join(unified_diff(_import_xml.split("\n"), _export_xml.split("\n"))) self.assertEqual( _import_xml, _export_xml, msg="For file {0}, export differs from import:\n{1}".format(_roundtrip, diff) )
def test_download_count_visible_and_updated_in_search_results(self): """ Verifies that the download count of a resource is visible and updated in the search results list. """ test_res = test_utils.import_xml( '{}/repository/fixtures/' 'downloadable_1_license.xml'.format(ROOT_PATH)) test_res.storage_object.published = True test_res.storage_object.save() client = Client() client.login(username='******', password='******') # to be on the safe side, clear any existing stats LRStats.objects.all().delete() # assert that the download/view counts are both zero at first: response = client.get(_SEARCH_PAGE_PATH) self.assertContains(response, 'title="Number of downloads" /> 0') self.assertContains(response, 'title="Number of views" /> 0')
def assert_import_equals_export(self, _roundtrip): _result = test_utils.import_xml(_roundtrip) with open(_roundtrip) as _import_file: _import_xml = _import_file.read() register_namespace('', SCHEMA_NAMESPACE) _import_xml = tostring(fromstring(_import_xml)) _export_xml = tostring(_result[0].export_to_elementtree()) # cfedermann: uncomment these lines to dump import/export XML to file. # #with open('/tmp/_import.xml', 'w') as _out: # _out.write(pretty_xml(_import_xml).encode('utf-8')) #with open('/tmp/_export.xml', 'w') as _out: # _out.write(pretty_xml(_export_xml).encode('utf-8')) _pretty_import = pretty_xml(_import_xml).strip().encode('utf-8') _pretty_export = pretty_xml(_export_xml).strip().encode('utf-8') diff = '\n'.join(unified_diff(_pretty_import.split('\n'), _pretty_export.split('\n'))) self.assertEqual(_pretty_import, _pretty_export, msg='For file {0}, export differs from import:\n{1}'.format(_roundtrip, diff))
def test_camel_case_aware_search(self): """ Asserts that the search engine is camelCase-aware. """ imported_res = test_utils.import_xml( "{}/repository/test_fixtures/" "internal-corpus-Text-EngPers.xml".format(ROOT_PATH) )[0] imported_res.storage_object.published = True imported_res.storage_object.save() client = Client() # assert that a two-token search finds a camelCase term: response = client.get("/{0}repository/search/".format(DJANGO_BASE), follow=True, data={"q": "speech synthesis"}) self.assertEqual("repository/search.html", response.templates[0].name) self.assertContains(response, "1 Language Resource", status_code=200) # assert that a camelCase search term also finds the camelCase term: response = client.get("/{0}repository/search/".format(DJANGO_BASE), follow=True, data={"q": "speechSynthesis"}) self.assertEqual("repository/search.html", response.templates[0].name) self.assertContains(response, "1 Language Resource", status_code=200)
def test_update(self): # define a maximum age of 4 seconds; this means that a resource is # checked for an update if it's older than 2 seconds settings.MAX_DIGEST_AGE = 6 # import resource _result = test_utils.import_xml(TESTFIXTURE_XML) _so = resourceInfoType_model.objects.get(pk=_result[0].id).storage_object self.assertIsNone(_so.digest_last_checked) # set status to ingested _so.publication_status = INGESTED _so.update_storage() _so = resourceInfoType_model.objects.get(pk=_result[0].id).storage_object self.assertIsNotNone(_so.digest_last_checked) # remember 'last_checked' and 'modified' to compare against it later _last_checked = _so.digest_last_checked _modified = _so.digest_modified # check if an update is required; this is not the case update_digests() _so = resourceInfoType_model.objects.get(pk=_result[0].id).storage_object # check that digest was not updated self.assertEquals(_modified, _so.digest_modified) self.assertEquals(_last_checked, _so.digest_last_checked) # wait 3 seconds and check again time.sleep(3) update_digests() _so = resourceInfoType_model.objects.get(pk=_result[0].id).storage_object # now an update should have happened, but the underlying data has not # changed, so digest_modified is not changed self.assertEquals(_modified, _so.digest_modified) # but it HAS been checked that the digest is still up-to-date self.assertNotEqual(_last_checked, _so.digest_last_checked) _last_checked = _so.digest_last_checked _modified = _so.digest_modified _checksum = _so.digest_checksum # get digest checksum; since not enough time has passed yet, the # digest is not updated _so.get_digest_checksum() self.assertEquals(_last_checked, _so.digest_last_checked) # again, wait 3 seconds so the digest requires another check time.sleep(3) self.assertEquals(_checksum, _so.get_digest_checksum()) self.assertEquals(_modified, _so.digest_modified) self.assertNotEqual(_last_checked, _so.digest_last_checked)
def test_camel_case_aware_search(self): """ Asserts that the search engine is camelCase-aware. """ imported_res = test_utils.import_xml('{}/repository/test_fixtures/' 'internal-corpus-Text-EngPers.xml'.format(ROOT_PATH)) imported_res.storage_object.published = True imported_res.storage_object.save() client = Client() # assert that a three-token search finds a camelCase term: response = client.get(_SEARCH_PAGE_PATH, follow=True, data={'q': 'camel case test'}) self.assertEqual('repository/search.html', response.templates[0].name) self.assertContains(response, "1 Language Resource", status_code=200) # assert that a camelCase search term also finds the camelCase term: response = client.get(_SEARCH_PAGE_PATH, follow=True, data={'q': 'camelCaseTest'}) self.assertEqual('repository/search.html', response.templates[0].name) self.assertContains(response, "1 Language Resource", status_code=200)
def test_update(self): # define a maximum age of 4 seconds; this means that a resource is # checked for an update if it's older than 2 seconds settings.MAX_DIGEST_AGE = 6 # import resource _result = test_utils.import_xml(TESTFIXTURE_XML) _so = resourceInfoType_model.objects.get(pk=_result.id).storage_object self.assertIsNone(_so.digest_last_checked) # set status to ingested _so.publication_status = INGESTED _so.update_storage() _so = resourceInfoType_model.objects.get(pk=_result.id).storage_object self.assertIsNotNone(_so.digest_last_checked) # remember 'last_checked' and 'modified' to compare against it later _last_checked = _so.digest_last_checked _modified = _so.digest_modified # check if an update is required; this is not the case update_digests() _so = resourceInfoType_model.objects.get(pk=_result.id).storage_object # check that digest was not updated self.assertEquals(_modified, _so.digest_modified) self.assertEquals(_last_checked, _so.digest_last_checked) # wait 3 seconds and check again time.sleep(3) update_digests() _so = resourceInfoType_model.objects.get(pk=_result.id).storage_object # now an update should have happened, but the underlying data has not # changed, so digest_modified is not changed self.assertEquals(_modified, _so.digest_modified) # but it HAS been checked that the digest is still up-to-date self.assertNotEqual(_last_checked, _so.digest_last_checked) _last_checked = _so.digest_last_checked _modified = _so.digest_modified _checksum = _so.digest_checksum # get digest checksum; since not enough time has passed yet, the # digest is not updated _so.get_digest_checksum() self.assertEquals(_last_checked, _so.digest_last_checked) # again, wait 3 seconds so the digest requires another check time.sleep(3) self.assertEquals(_checksum, _so.get_digest_checksum()) self.assertEquals(_modified, _so.digest_modified) self.assertNotEqual(_last_checked, _so.digest_last_checked)
def setUp(self): """ Import a resource to test the workflow changes for """ test_utils.set_index_active(False) test_utils.setup_test_storage() _test_editor_group = \ EditorGroup.objects.create(name='test_editor_group') _test_manager_group = \ EditorGroupManagers.objects.create(name='test_manager_group', managed_group=_test_editor_group) test_utils.create_manager_user( 'manageruser', '*****@*****.**', 'secret', (_test_editor_group, _test_manager_group)) _fixture = '{0}/repository/fixtures/testfixture.xml'.format(ROOT_PATH) _result = test_utils.import_xml(_fixture) _result.editor_groups.add(_test_editor_group) StatusWorkflowTest.resource_id = _result.id
def test_sitemap(self): """ Tests the correct appearance of the sitemap """ imported_res = test_utils.import_xml('{}/repository/fixtures/' 'testfixture.xml'.format(ROOT_PATH)) imported_res.storage_object.published = True imported_res.storage_object.save() client = Client() # Assert that the sitemap page contains the xmlsn and the entry # of the imported resource. response = client.get(SITEMAP_URL) self.assertEqual(response.status_code, 200) self.assertContains(response, '<urlset xmlns="http://www.sitemaps.org/schemas/sitemap/0.9">') self.assertContains(response, '{}/repository/browse/italian-tts-speech-corpus-appen/' \ .format(DJANGO_URL))
def setUp(self): test_utils.setup_test_storage() _fixture = '{0}/repository/fixtures/testfixture.xml'.format(ROOT_PATH) _result = test_utils.import_xml(_fixture) self.resource_id = _result.id resource = resourceInfoType_model.objects.get(pk=self.resource_id) resource.storage_object.published = True resource.storage_object.save() # set up test users with and without staff permissions. # These will live in the test database only, so will not # pollute the "normal" development db or the production db. # As a consequence, they need no valuable password. staffuser = User.objects.create_user('staffuser', '*****@*****.**', 'secret') staffuser.is_staff = True staffuser.save() User.objects.create_user('normaluser', '*****@*****.**', 'secret') super(ExampleSeleniumTest, self).setUp() self.base_url = '{0}/{1}'.format(DJANGO_URL, DJANGO_BASE)
def assert_import_equals_export(self, _roundtrip): _result = test_utils.import_xml(_roundtrip) with open(_roundtrip) as _import_file: _import_xml = _import_file.read() register_namespace('', SCHEMA_NAMESPACE) _import_xml = to_xml_string(fromstring(_import_xml), encoding="utf-8") _export_xml = to_xml_string(_result.export_to_elementtree(), encoding="utf-8") # cfedermann: uncomment these lines to dump import/export XML to file. # #with open('/tmp/_import.xml', 'wb') as _out: # _out.write(_import_xml.encode('utf-8')) #with open('/tmp/_export.xml', 'wb') as _out: # _out.write(_export_xml.encode('utf-8')) diff = '\n'.join( unified_diff(_import_xml.split('\n'), _export_xml.split('\n'))) self.assertEqual( _import_xml, _export_xml, msg='For file {0}, export differs from import:\n{1}'.format( _roundtrip, diff.encode('utf-8')))