def test_registered_user(self):
"""Test registered user."""
user = User(self.site, 'Xqt')
with suppress_warnings('pywikibot.page.User.name', DeprecationWarning):
self.assertEqual(user.name(), user.username)
self.assertEqual(user.title(withNamespace=False), user.username)
self.assertTrue(user.isRegistered())
self.assertFalse(user.isAnonymous())
self.assertIsInstance(user.registration(), pywikibot.Timestamp)
self.assertGreater(user.editCount(), 0)
self.assertFalse(user.isBlocked())
self.assertTrue(user.isEmailable())
self.assertEqual(user.gender(), 'unknown')
self.assertIn('userid', user.getprops())
self.assertEqual(user.getprops()['userid'], 287832)
self.assertEqual(user.pageid, 6927779)
self.assertEqual(user.getUserPage(),
pywikibot.Page(self.site, 'Benutzer:Xqt'))
self.assertEqual(user.getUserPage(subpage='pwb'),
pywikibot.Page(self.site, 'Benutzer:Xqt/pwb'))
self.assertEqual(user.getUserTalkPage(),
pywikibot.Page(self.site, 'Benutzer Diskussion:Xqt'))
self.assertEqual(user.getUserTalkPage(subpage='pwb'),
pywikibot.Page(self.site,
'Benutzer Diskussion:Xqt/pwb'))
self.assertTrue(user.is_thankable)
contribs = user.contributions(total=10)
self.assertEqual(len(list(contribs)), 10)
self.assertTrue(all(isinstance(contrib, tuple)
for contrib in contribs))
self.assertTrue(all('user' in contrib
and contrib['user'] == user.username
for contrib in contribs))
self.assertIn('user', user.groups())
self.assertIn('edit', user.rights())
def test_checkstr(self):
"""Test for extracting key and duration from shorthand notation of durations."""
self.assertEqual(archivebot.checkstr('400s'), ('s', '400'))
with suppress_warnings('Time period without qualifier', UserWarning):
self.assertEqual(archivebot.checkstr('3000'), ('s', '3000'))
self.assertEqual(archivebot.checkstr('7d'), ('d', '7'))
self.assertEqual(archivebot.checkstr('3y'), ('y', '3'))
# Should pass, because the key is verified in str2time
self.assertEqual(archivebot.checkstr('4000@'), ('@', '4000'))
def test_anonymous_user(self):
"""Test registered user."""
user = User(self.site, '123.45.67.89')
with suppress_warnings('pywikibot.page.User.name', DeprecationWarning):
self.assertEqual(user.name(), user.username)
self.assertEqual(user.title(withNamespace=False), user.username)
self.assertFalse(user.isRegistered())
self.assertTrue(user.isAnonymous())
self.assertIsNone(user.registration())
self.assertFalse(user.isEmailable())
self.assertEqual(user.gender(), 'unknown')
self.assertIn('invalid', user.getprops())
self.assertFalse(user.is_thankable)
def test_unregistered_user(self):
"""Test unregistered user."""
user = User(self.site, 'This user name is not registered yet')
with suppress_warnings('pywikibot.page.User.name', DeprecationWarning):
self.assertEqual(user.name(), user.username)
self.assertEqual(user.title(withNamespace=False), user.username)
self.assertFalse(user.isRegistered())
self.assertFalse(user.isAnonymous())
self.assertIsNone(user.registration())
self.assertFalse(user.isEmailable())
self.assertEqual(user.gender(), 'unknown')
self.assertIn('missing', user.getprops())
self.assertFalse(user.is_thankable)
def test_anonymous_user(self):
"""Test registered user."""
user = User(self.site, '123.45.67.89')
with suppress_warnings('pywikibot.page.User.name', DeprecationWarning):
self.assertEqual(user.name(), user.username)
self.assertEqual(user.title(with_ns=False), user.username)
self.assertFalse(user.isRegistered())
self.assertTrue(user.isAnonymous())
self.assertIsNone(user.registration())
self.assertFalse(user.isEmailable())
self.assertEqual(user.gender(), 'unknown')
self.assertIn('invalid', user.getprops())
self.assertFalse(user.is_thankable)
def test_modules(self):
"""Test v1.8 modules exist."""
site = self.get_site()
pi = api.ParamInfo(site)
with suppress_warnings(
r'pywikibot\.data\.api\.ParamInfo.modules is deprecated for '
r'[\w ]+; use submodules\(\) or module_paths instead\.',
DeprecationWarning):
self.assertIn('revisions', pi.modules)
self.assertIn('help', pi.modules)
self.assertIn('allpages', pi.modules)
for mod in pi.modules:
self.assertNotIn('+', mod)
def test_unregistered_user(self):
"""Test unregistered user."""
user = User(self.site, 'This user name is not registered yet')
with suppress_warnings('pywikibot.page.User.name', DeprecationWarning):
self.assertEqual(user.name(), user.username)
self.assertEqual(user.title(with_ns=False), user.username)
self.assertFalse(user.isRegistered())
self.assertFalse(user.isAnonymous())
self.assertIsNone(user.registration())
self.assertFalse(user.isEmailable())
self.assertEqual(user.gender(), 'unknown')
self.assertIn('missing', user.getprops())
self.assertFalse(user.is_thankable)
def testApiMethods(self):
"""Test various methods that rely on API."""
mainpage = self.get_mainpage()
# since there is no way to predict what data the wiki will return,
# we only check that the returned objects are of correct type.
self.assertIsInstance(mainpage.get(), unicode)
with suppress_warnings(r'pywikibot\.page\.BasePage\.latestRevision '
r'is deprecated[\s\w]+; '
r'use latest_revision_id instead\.'):
self.assertIsInstance(mainpage.latestRevision(), int)
self.assertIsInstance(mainpage.userName(), unicode)
self.assertIsInstance(mainpage.isIpEdit(), bool)
self.assertIsInstance(mainpage.exists(), bool)
self.assertIsInstance(mainpage.isRedirectPage(), bool)
with suppress_warnings(
r'pywikibot\.page\.BasePage\.isEmpty is deprecated[\s\w]+; '
r'use interwiki\.page_empty_check\(page\) instead\.'):
self.assertIsInstance(mainpage.isEmpty(), bool)
self.assertIsInstance(mainpage.isDisambig(), bool)
self.assertIsInstance(mainpage.has_permission(), bool)
self.assertIsInstance(mainpage.botMayEdit(), bool)
self.assertIsInstance(mainpage.editTime(), pywikibot.Timestamp)
self.assertIsInstance(mainpage.permalink(), basestring)
def _test_config_settings(self):
"""Test if method honours configuration toggle."""
with suppress_warnings(r'.*?get_fake_user_agent is deprecated'):
# ON: True and None in config are considered turned on.
config.fake_user_agent = True
self.assertNotEqual(http.get_fake_user_agent(), http.user_agent())
config.fake_user_agent = None
self.assertNotEqual(http.get_fake_user_agent(), http.user_agent())
# OFF: All other values won't make it return random UA.
config.fake_user_agent = False
self.assertEqual(http.get_fake_user_agent(), http.user_agent())
config.fake_user_agent = 'ARBITRARY'
self.assertEqual(http.get_fake_user_agent(), 'ARBITRARY')
def test_registered_user(self):
"""Test registered user."""
user = User(self.site, 'Xqt')
with suppress_warnings():
self.assertEqual(user.name(), user.username)
self.assertEqual(user.title(withNamespace=False), user.username)
self.assertTrue(user.isRegistered())
self.assertFalse(user.isAnonymous())
self.assertIsInstance(user.registration(), pywikibot.Timestamp)
self.assertGreater(user.editCount(), 0)
self.assertFalse(user.isBlocked())
self.assertTrue(user.isEmailable())
self.assertEqual(user.gender(), 'unknown')
self.assertIn('userid', user.getprops())
def test_url_based_authentication(self):
"""Test url-based authentication info."""
pairs = {
'https://zh.wikipedia.beta.wmflabs.org': ('1', '2'),
'https://en.wikipedia.beta.wmflabs.org': ('3', '4', '3', '4'),
'https://wiki.beta.wmflabs.org': ('5', '6'),
'https://beta.wmflabs.org': None,
'https://wmflabs.org': None,
'https://www.wikiquote.org/': None,
}
with suppress_warnings(
r'config.authenticate\["\*.wmflabs.org"] has invalid value.',
UserWarning,
):
for url, auth in pairs.items():
self.assertEqual(http.get_authentication(url), auth)
def test_wrapper(self):
"""Create a test instance and verify the wrapper redirects."""
obj = self.DummyClass()
with suppress_warnings(
'pywikibot.tools.ContextManagerWrapper is deprecated.'):
wrapped = tools.ContextManagerWrapper(obj)
self.assertIs(wrapped.class_var, obj.class_var)
self.assertIs(wrapped.instance_var, obj.instance_var)
self.assertIs(wrapped._wrapped, obj)
self.assertFalse(obj.closed)
with wrapped as unwrapped:
self.assertFalse(obj.closed)
self.assertIs(unwrapped, obj)
unwrapped.class_var = 47
self.assertTrue(obj.closed)
self.assertEqual(wrapped.class_var, 47)
def _apply(self, bot, expected, missing=None, title='Test page'):
"""Test applying a test change."""
applied = set()
if missing is True:
required_applied = set()
else:
required_applied = set(bot.replacements)
if missing:
required_applied -= set(missing)
# shouldn't be edited anyway
page = pywikibot.Page(self.site, title)
self.assertEqual(expected,
bot.apply_replacements('Hello 1', applied, page))
self.assertEqual(applied, required_applied)
with suppress_warnings('scripts.replace.ReplaceRobot.doReplacements'):
self.assertEqual(expected, bot.doReplacements('Hello 1', page))
def test_xml_start_variants(self):
"""Test the generator using variants of start page."""
start_variants = (
'-xmlstart:Fake page', # title
'-xmlstart:Fake_page', # underscore
'-xmlstart:Fake', # prefix
)
filename = '-xml:' + join_xml_data_path('dummy-reflinks.xml')
for start in start_variants:
with self.subTest(xmlstart=start):
with suppress_warnings(WARN_SITE_OBJ, category=UserWarning):
main(filename, '-namespace:1', start)
gen = self.constructor_kwargs['generator']
pages = list(gen)
self.assertPageTitlesEqual(pages, ['Talk:Fake page'],
site=self.site)
def test_autoblocked_user_with_namespace(self):
"""Test autoblocked user."""
# Suppress output: This is an autoblock ID, you can only use to unblock
with patch.object(pywikibot, 'output'):
user = User(self.site, 'User:#1242976')
self.assertEqual('#1242976', user.username)
with suppress_warnings('pywikibot.page.User.name is deprecated'):
self.assertEqual(user.name(), user.username)
self.assertEqual(user.title(with_ns=False), user.username[1:])
self.assertFalse(user.isRegistered())
self.assertFalse(user.isAnonymous())
self.assertIsNone(user.registration())
self.assertFalse(user.isEmailable())
self.assertIn('invalid', user.getprops())
self.assertTrue(user._isAutoblock)
self.assertRaisesRegex(AutoblockUser, 'This is an autoblock ID',
user.getUserPage)
self.assertRaisesRegex(AutoblockUser, 'This is an autoblock ID',
user.getUserTalkPage)
def test_from_json(self):
"""Test Notification.fromJSON class method and instance attributes."""
notif = Notification.fromJSON(self.get_site(), self.data)
self.assertIsInstance(notif, Notification)
self.assertEqual(notif.site, self.get_site())
with suppress_warnings(category=DeprecationWarning):
notif_id = notif.id
self.assertEqual(notif_id, self.data['id'])
self.assertEqual(int(notif_id), notif.event_id)
self.assertEqual(notif.type, self.data['type'])
self.assertEqual(notif.category, self.data['category'])
self.assertIsInstance(notif.timestamp, pywikibot.Timestamp)
self.assertEqual(notif.timestamp.totimestampformat(),
self.data['timestamp']['mw'])
self.assertIsInstance(notif.agent, pywikibot.User)
self.assertIsNone(notif.page)
self.assertEqual(notif.agent.title(with_ns=False),
self.data['agent']['name'])
self.assertFalse(notif.read)
self.assertEqual(notif.content, self.data['*'])
self.assertIsNone(notif.revid)
def setUp(self):
"""Initialize the fake requests."""
super(DryCachedRequestTests, self).setUp()
self.parms = {'action': 'query',
'meta': 'userinfo'}
self.req = CachedRequest(expiry=1, site=self.basesite,
parameters=self.parms)
self.expreq = CachedRequest(expiry=0, site=self.basesite,
parameters=self.parms)
self.diffreq = CachedRequest(
expiry=1, site=self.basesite,
parameters={'action': 'query', 'meta': 'siteinfo'})
self.diffsite = CachedRequest(
expiry=1, site=self.altsite,
parameters={'action': 'query', 'meta': 'userinfo'})
# When using ** the paramters are still unicode
with suppress_warnings('Instead of using kwargs ', DeprecationWarning):
self.deprecated_explicit = CachedRequest(
expiry=1, site=self.basesite, action='query', meta='userinfo')
self.deprecated_asterisks = CachedRequest(
expiry=1, site=self.basesite, **self.parms)
def test_other_submodule(self):
"""Test another module apart from query having submodules."""
pi = api.ParamInfo(self.site)
self.assertFalse(pi._modules)
pi.fetch(['query'])
self.assertNotIn('flow', pi._modules)
pi.fetch(['flow'])
self.assertIn('flow', pi._modules)
other_modules = set()
for modules in pi._modules.values():
self.assertIsInstance(modules, frozenset)
other_modules |= modules
other_modules -= pi.action_modules
other_modules -= pi.query_modules
self.assertLessEqual(other_modules & pi.submodules('flow'),
pi.submodules('flow'))
with suppress_warnings(
r'pywikibot.data.api.ParamInfo.modules is deprecated; '
r'use submodules\(\) or module_paths instead.'):
self.assertFalse(other_modules & pi.modules)
def test_base_methods(self):
"""Test cases for BaseSite methods."""
mysite = self.get_site()
code = self.site.family.obsolete.get(self.code) or self.code
self.assertEqual(mysite.family.name, self.family)
self.assertEqual(mysite.code, code)
self.assertIsInstance(mysite.lang, str)
self.assertEqual(mysite, pywikibot.Site(self.code, self.family))
self.assertIsInstance(mysite.user(), (str, type(None)))
self.assertEqual(mysite.sitename, '{}:{}'.format(self.family, code))
self.assertIsInstance(mysite.linktrail(), str)
self.assertIsInstance(mysite.redirect(), str)
# sitename attribute could also be referenced like a function
with suppress_warnings(WARN_SELF_CALL, category=FutureWarning):
self.assertEqual(mysite.sitename(),
'{}:{}'.format(self.family, code))
try:
dabcat = mysite.disambcategory()
except Error as e:
try:
self.assertIn('No disambiguation category name found', str(e))
except AssertionError:
self.assertIn(
'No {repo} qualifier found for disambiguation category '
'name in {fam}_family file'.format(
repo=mysite.data_repository().family.name,
fam=mysite.family.name), str(e))
else:
self.assertIsInstance(dabcat, pywikibot.Category)
foo = str(pywikibot.Link('foo', source=mysite))
if self.site.namespaces[0].case == 'case-sensitive':
self.assertEqual(foo, '[[foo]]')
def update_sites(fam):
"""Process linktrail for a given site code."""
formatter = update_line()
while True:
code = yield
with suppress_warnings(
'Site wikipedia:[{}]+ instantiated using different code'.
format(CODE_CHARACTERS),
category=UserWarning,
filename=r'.+pywikibot.tools.__init__\.py'):
site = pywikibot.Site(code, 'wikipedia')
if isinstance(site, pywikibot.site.RemovedSite):
continue
if site.code != code:
pywikibot.output('"{}" is redirected to "{}"; skipping.'.format(
code, site.code))
continue
linktrail = site.siteinfo.get('general', expiry=True)['linktrail']
oldtrail = fam.linktrails.get(code)
formatter.send((code, oldtrail, linktrail))
#!/usr/bin/python
"""Module containing special bots reusable by scripts."""
#
# (C) Pywikibot team, 2020-2021
#
# Distributed under the terms of the MIT license.
#
from pywikibot.specialbots._unlink import BaseUnlinkBot, InteractiveUnlink
from pywikibot.specialbots._upload import UploadRobot
from pywikibot.tools import ModuleDeprecationWrapper, suppress_warnings
with suppress_warnings(category=FutureWarning):
from pywikibot.specialbots._unlink import EditReplacement
__all__ = (
'BaseUnlinkBot',
'EditReplacement',
'InteractiveUnlink',
'UploadRobot',
)
wrapper = ModuleDeprecationWrapper(__name__)
wrapper._add_deprecated_attr(
'EditReplacement',
replacement_name='pywikibot.exceptions.EditReplacementError',
since='20210423',
future_warning=True)
