def getRewardsPoints(self):
"""
Returns rewards points as int
"""
# report activity
postFields = urllib.urlencode( { "url" : bingCommon.BING_URL, "V" : "web" } )
url = "http://www.bing.com/rewardsapp/reportActivity"
request = urllib2.Request(url, postFields, self.httpHeaders)
request.add_header("Referer", bingCommon.BING_URL)
with self.opener.open(request) as response:
page = helpers.getResponseBody(response)
if len(page) == 0:
raise Exception("Rewards points page is empty. That could mean you are not signed up for rewards with this account")
# There are instances where the account appears to be signed in, but really is not
helpers.errorOnText(page, "You are not signed", "Temporary account ban: User was not successfully signed in.\n")
# parse activity page
s = page.index("t.innerHTML='")
s += len("t.innerHTML='")
e = page.index("'", s)
rewardsText = page[s:e]
if rewardsText == 'Rewards': # The account is banned
raise helpers.BingAccountError("Banned from BingRewards: Could not get the number of rewards.")
else:
return int(rewardsText)
def parseDashboardPage(page, bing_url):
"""
Parses a bing dashboard page
returns a list of Reward objects
page - bing dashboard page - see the class __doc__ for further information
bing_url - url of bing main page - generally http://www.bing.com which will be
added to Reward.url as a prefix if appropriate
"""
reload(sys)
sys.setdefaultencoding('utf8')
if page is None: raise TypeError("page is None")
if page.strip() == "": raise ValueError("page is empty")
allRewards = []
# if this is the new type of dashboard page (there's probably a better way to figure this out)
if page.find("rewards-oneuidashboard") != -1:
page = page.split("var dashboard")[1]
# Rewards can be listed more than once so track here and skip those that are already complete
allTitles = set()
for attrPair in page.split(',"'):
current = attrPair.replace('"', '').split(':')
if current[0] == "title":
currentTitle = current[1].strip()
if currentTitle in allTitles:
# already have this reward, skip it
continue
else:
newRwd = Reward()
allTitles.add(currentTitle)
validRwd = createRewardNewFormat(page, currentTitle,
newRwd)
if validRwd:
allRewards.append(newRwd)
elif page.find(
"Uh oh, it appears your Microsoft Rewards account has been suspended."
) != -1:
raise helpers.BingAccountError(
"Your Microsoft Rewards account has been suspended")
else:
raise helpers.BingAccountError("Unrecognized dashboard page")
return allRewards
class TestConfig(unittest.TestCase):
fsock = None
mockdate = "2017-09-06 00:44:47.7"
def _redirectOut(self): # pragma: no cover
self.fsock = open('out.log', 'a+')
sys.stdout = self.fsock
def tearDown(self): # pragma: no cover
if self.fsock is not None:
self.fsock.close()
self.fsock = None
sys.stdout = sys.__stdout__
def setUp(self):
self.config = Config()
self.configXMLString = XMLString
self.config.parseFromString(self.configXMLString)
self.configFBXML = FBXML
def test_timestamp(self):
"""
test getlogtime
:return:
"""
stamp = helpers.getLoggingTime()
self.assertRegexpMatches(stamp, "\d{4}-\d{2}-\d{2}", "should have time stamp,\n" + stamp)
def test_createdir(self):
"""
test dir with file
:return:
"""
helpers.createResultsDir("none")
self.assertEqual(os.path.isdir(helpers.RESULTS_DIR), True, "missing directory " + helpers.RESULTS_DIR)
@patch('os.path.dirname', new=Mock(side_effect=OSError("fail to mock a write", errno.EACCES)))
def test_createdir_raise(self):
"""
test dir raise error
:return:
"""
self.assertRaisesRegexp(OSError, "fail to mock", helpers.createResultsDir, "none")
@patch('os.path.dirname', new=Mock(side_effect=OSError("fail to mock a write", errno.EEXIST)))
def test_createdir_fail(self):
"""
test dir with failing oserror
:return:
"""
self.assertRaisesRegexp(OSError, "fail to mock", helpers.createResultsDir, "none")
def test_dump_none(self):
"""
test none page to a file
:return:
"""
self.assertRaisesRegexp(TypeError, "None", helpers.dumpErrorPage, None)
def test_dump(self):
"""
test dump page to a file
:return:
"""
filename = helpers.dumpErrorPage(self.mockdate)
output = ""
with open("result/" + filename, "r") as fd:
output += fd.readline()
self.assertRegexpMatches(output, "\d{4}-\d{2}-\d{2}", "should have time stamp,\n" + output)
def test_errorontext(self):
"""
test exception from helper's errorOnText
:return:
"""
err = 'Authentication has not been passed: Invalid password'
# not found so no assertion
output = helpers.errorOnText("", 'That password is incorrect.', err)
# should raise if it sees an assertion
self.assertRaisesRegexp(helpers.BingAccountError, "Invalid", helpers.errorOnText, 'That password is incorrect.',
'That password is incorrect.', err)
def test_node(self):
"""
test node's children
:return:
"""
import xml.etree.ElementTree as ET
root = ET.fromstring(self.configXMLString)
node = helpers.getXmlChildNodes(root)
self.assertIsNotNone(node, "should not be null " + str(node))
@patch('sys.version_info')
def test_node_fail(self, mockver):
sys.version_info = [2, 1]
import xml.etree.ElementTree as ET
root = ET.fromstring(self.configXMLString)
node = helpers.getXmlChildNodes(root)
self.assertIsNotNone(node, "should not be null " + str(node))
def test_accounts(self):
self.assertIsNotNone(self.config.accounts)
self.assertEqual(len(self.config.accounts), 1)
accounts = dict()
acc = Config.Account()
acc.accountLogin = "******"
acc.password = "******"
acc.accountType = "Live"
acc.disabled = False
acc.ua_desktop = "Mozilla/5.0 (Windows NT 10.0) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/42.0.2311.135 Safari/537.36 Edge/12.10136"
acc.ua_mobile = "mozilla/5.0 (iphone; cpu iphone os 7_0_2 like mac os x) applewebkit/537.51.1 (khtml, like gecko) version/7.0 mobile/11a501 safari/9537.53"
accounts[acc.getRef()] = acc
self.assertEqual(accounts, self.config.accounts)
def test_history(self):
"""
test history parsing
:return:
"""
self.assertRaisesRegexp(TypeError, "None", bingHistory.parse, None)
output = bingHistory.parse("")
self.assertIsNotNone(output, "missing output " + str(output))
page = '<span class="query_t">'
page += '<div id="results_area"></div><div id="sidebar"></div>'
output = bingHistory.parse(page)
self.assertIsNotNone(output, "missing output " + str(output))
page = '<span class="sh_item_qu_query">'
page += '<ul class="sh_dayul"></ul>'
page += ' value == 0'
page += '</span>'
output = bingHistory.parse(page)
self.assertIsNotNone(output, "missing output " + str(output))
page = '<ul class="sh_dayul"> </ul>'
output = bingHistory.parse(page)
self.assertIsNotNone(output, "missing output " + str(output))
output = bingHistory.getBingHistoryTodayURL()
self.assertRegexpMatches(output, "https", "missing url " + str(output))
@patch('helpers.getResponseBody', return_value='"WindowsLiveId":"" "WindowsLiveId":""')
@patch('time.sleep', return_value='')
def test_auth_url(self, timemock, helpmock): # pragma: no cover
"""
test authentication decoding error
:return:
"""
self.assertRaisesRegexp(ValueError, "unknown url type", run, self.config)
@patch('bingAuth.BingAuth.authenticate',
new=Mock(side_effect=SocketError(errno.ECONNREFUSED, "errno.ECONNREFUSED")))
def test_auth_exceptionSock(self):
self.assertRaisesRegexp(SocketError, "", run, self.config)
@patch('bingAuth.BingAuth.authenticate', new=Mock(side_effect=SocketError(errno.ECONNRESET, "errno.ECONNRESET")))
def test_auth_exceptionSockReset(self):
self.assertIsNone(run(self.config), "should not return anything")
@patch('bingAuth.BingAuth.authenticate', new=Mock(side_effect=helpers.BingAccountError(None)))
def test_auth_exceptionBing(self):
self.assertIsNone(run(self.config), "should not return anything")
@patch('bingAuth.BingAuth.authenticate', new=Mock(side_effect=urllib2.URLError("")))
def test_auth_exceptionURL(self):
self.assertIsNone(run(self.config), "should not return anything")
@patch('bingAuth.BingAuth.authenticate', new=Mock(side_effect=HTMLParser.HTMLParseError("error")))
def test_auth_exceptionParser(self):
self.assertIsNone(run(self.config), "should not return anything")
@patch('bingAuth.BingAuth.authenticate', new=Mock(side_effect=urllib2.HTTPError("", "", "", "", open("tmp", "a+"))))
def test_auth_exceptionHTTP(self):
self.assertIsNone(run(self.config), "should not return anything")
def test_stringify(self):
self.assertRaisesRegexp(ValueError, "too small", stringify, None, -1)
@patch('urllib2.Request', return_value="")
@patch('helpers.getResponseBody', return_value="")
@patch('urllib2.Request.add_header', return_value=urllib2.Request(bingCommon.BING_URL, bingCommon.HEADERS))
def test_auth_url(self, headermock, helpmock, urlmock):
"""
test auth class
:param headermock:
:param helpmock:
:param urlmock:
:return:
"""
self.assertRaisesRegexp(TypeError, "opener is not", bingAuth.BingAuth, bingCommon.HEADERS, None)
auth = bingAuth.BingAuth(bingCommon.HEADERS, urllib2.OpenerDirector())
self.assertIsNotNone(auth, "should return class")
def test_config(self):
"""
test config module
:return:
"""
configobj = Config()
self.assertIsNotNone(configobj, "should return class")
self.assertIsNotNone(Config.General(), "should return class")
self.assertIsNotNone(ConfigError("ok"), "should return exception")
self.assertIsNotNone(Config.Proxy(), "should return class")
self.assertIsNotNone(Config.EventAccount(), "should return class")
self.assertIsNotNone(Config.Event.Notify(), "should return class")
ifs = Config.Event.IfStatement()
ifs.op = lambda x, y: x
ifs.lhs = lambda x: x
ifs.rhs = "b"
self.assertIsNotNone(str(ifs), "should return class")
self.assertRaisesRegexp(ValueError, "None", ifs.evaluate, None)
self.assertRaisesRegexp(TypeError, "is not of", ifs.evaluate, [])
self.assertIsNotNone(ifs.evaluate(BingRewardsReportItem()))
spec = Config.Event.Specifier()
self.assertIsNotNone(spec, "should return class")
self.assertRaisesRegexp(ValueError, "is None", spec.evaluate, None, BingRewardsReportItem())
self.assertRaisesRegexp(TypeError, "list", spec.evaluate, [], BingRewardsReportItem())
self.assertRaisesRegexp(ValueError, "is None", spec.evaluate, [], None)
self.assertRaisesRegexp(TypeError, "not of BingRewardsReportItem type", spec.evaluate, [], self.config)
self.assertIsNotNone(spec.evaluate("%a", BingRewardsReportItem()), "should return string")
dist = os.path.join(os.path.dirname(__file__), "..", "config.xml")
self.assertIsNone(configobj.parseFromFile(dist), "should be none")
self.assertRaisesRegexp(ValueError, "_configFile_ is None", configobj.parseFromFile, None)
self.assertRaisesRegexp(ValueError, "is None", self.config.parseFromString, None)
self.assertRaisesRegexp(ConfigError, "Invalid subnode", configobj.parseFromString, InvalidXML)
self.assertRaisesRegexp(ConfigError, "is not found", configobj.parseFromString, LOGINXML)
self.assertRaisesRegexp(ConfigError, "is not found", configobj.parseFromString, PWDXML)
self.assertRaisesRegexp(ConfigError, "should be either set", self.config.parseFromString, PROXYLOGINXML)
self.assertRaisesRegexp(KeyError, "_specifier_ is not", validateSpecifier, "%not")
self.assertRaisesRegexp(ConfigError, "Invalid subnode", self.config.parseFromString, FBXML)
def test_config_attr(self):
self.assertRaisesRegexp(ConfigError, "MUST", self.config.parseFromString, FLOAT)
self.assertRaisesRegexp(ConfigError, "MUST", self.config.parseFromString, INT)
self.assertRaisesRegexp(ConfigError, "must", self.config.parseFromString, NONFLOAT)
self.assertRaisesRegexp(ConfigError, "must", self.config.parseFromString, NONINT)
def test_config_notify(self):
self.assertRaisesRegexp(ConfigError, "is not found", self.config.parseFromString, NONREF)
self.assertRaisesRegexp(ConfigError, "is not found", self.config.parseFromString, NONACCREF)
self.assertRaisesRegexp(ConfigError, "not supported", self.config.parseFromString, NONEV)
def test_config_retry(self):
self.assertRaisesRegexp(ConfigError, "is not found", self.config.parseFromString, RETRY)
self.assertRaisesRegexp(ConfigError, "must be", self.config.parseFromString, INVRETRY)
self.assertRaisesRegexp(ConfigError, "MUST BE", self.config.parseFromString, NEGRETRY)
self.assertRaisesRegexp(ConfigError, "is not found", self.config.parseFromString, RETRYCNT)
self.assertRaisesRegexp(ConfigError, "must be", self.config.parseFromString, INVRETRYCNT)
self.assertRaisesRegexp(ConfigError, "MUST BE", self.config.parseFromString, NEGRETRYCNT)
def test_config_if(self):
self.assertRaisesRegexp(ConfigError, "is invalid", self.config.parseFromString, NONIF2)
self.assertRaisesRegexp(ConfigError, "is invalid", self.config.parseFromString, NONIFRHS)
self.assertRaisesRegexp(ConfigError, "is invalid", self.config.parseFromString, NONIFOP)
def test_event(self):
"""
test event
:return:
"""
self.assertIsNone(EventsProcessor.onScriptFailure(self.config, Exception()), "should be none")
self.assertIsNone(EventsProcessor.onScriptComplete(self.config), "should be none")
self.assertRaisesRegexp(ConfigError, "not found", self.config.parseFromString, EVENT)
self.config.parseFromString(EVENTLESS)
self.assertRaisesRegexp(Exception, ".*", EventsProcessor.onScriptFailure, self.config, Exception())
self.assertIsNone(EventsProcessor.onScriptComplete(self.config), "should be none")
ep = EventsProcessor(self.config, BingRewardsReportItem())
self.assertIsNotNone(ep.processReportItem(), "should not be none and be done")
@patch('main.earnRewards', return_value=None)
@patch('eventsProcessor.EventsProcessor.processReportItem', return_value=(-1, None))
def test_event_dontcare(self, mockep, mockmain):
# not retry nor ok with -1
self.assertIsNone(processAccount(self.config), "should return nothing")
def test_event_getEvent_returnsEvent(self):
"""
test onScriptFailure using echo from xml config string
:return:
"""
event = self.config.getEvent(Config.Event.onScriptFailure)
self.assertIsNotNone(event)
self.assertTrue(len(event.notifies) == 1)
self.assertEqual(event.notifies[0].cmd, "echo")
def test_event_getEvent_returnsNoneIfEventDoesntExist(self):
"""
test no event call does not exist
:return:
"""
self.assertIsNone(self.config.getEvent("does_not_exist"))
self.assertRaisesRegexp(ValueError, "None", self.config.getEvent, None)
def test_reward_bfp_hit(self):
self._rewards_hit(bfp.RewardV1())
self._rewards_hit(bdp.Reward())
@patch('helpers.getResponseBody')
def _rewards_hit(self, classobj, helpmock):
"""
test rewards object
:return:
"""
self.config.proxy = False
reward = BingRewards(bingCommon.HEADERS, "", self.config)
page = '"WindowsLiveId":"" "WindowsLiveId":"" '
page += 'action="0" value="0" '
page += 'value= "0" NAP value="0" '
page += 'ANON value="0" '
page += 'id="t" value="0" '
page += '<div> 999 livetime points</div> '
helpmock.return_value = page
# if not login should have not found error for url
self.assertIsNotNone(reward.getLifetimeCredits, "Should return int")
page = "t.innerHTML='100'"
helpmock.return_value = page
self.assertIsNotNone(reward.getRewardsPoints(), "should not be None")
self.assertRaisesRegexp(TypeError, "not an instance", reward.process, None, True)
# NONE case
newbfp = classobj
newbfp.tp = None
rewards = [newbfp]
self.assertIsNotNone(reward.process(rewards, True), "handle not none")
# HIT case
newbfp.tp = mock.Mock()
newbfp.tp = [0, 1, 2, 3, bfp.RewardV1.Type.Action.HIT]
# SEARCH case
newbfp.tp = mock.Mock()
newbfp.tp = [0, 1, 2, 3, bfp.RewardV1.Type.Action.SEARCH]
newbfp.progressCurrent = 100
rewards = [newbfp]
self.assertIsNotNone(reward.process(rewards, True), "should return res")
self.assertRaisesRegexp(TypeError, "not an instance", reward.printResults, None, True)
result = mock.Mock()
result.action = bfp.RewardV1.Type.Action.SEARCH
result.isError = True
result.o = newbfp
result.message = "done"
newbfp.progressCurrent = 1
newbfp.progressMax = 100
newbfp.url = "http:0.0.0.0"
self.assertIsNone(reward.printResults([result], True), "should return None")
self.assertRaisesRegexp(TypeError, "rewards is not", reward.printRewards, None)
rewards[0].isDone = True
self.assertIsNone(reward.printRewards(rewards), "should return None")
self.assertRaisesRegexp(TypeError, "reward is not", reward.RewardResult, None)
self.assertIsNotNone(reward.RewardResult(newbfp), "should return class")
proxy = mock.Mock()
proxy.login = True
proxy.password = "******"
proxy.url = "http://127.0.0.1"
proxy.protocols = "http"
self.config.proxy = proxy
self.assertIsNotNone(BingRewards(bingCommon.HEADERS, "", self.config), "should return class")
proxy.login = False
self.config.proxy = proxy
self.assertIsNotNone(BingRewards(bingCommon.HEADERS, "", self.config), "should return class")
self.assertRaisesRegexp(ConfigError, "not found", self.config.parseFromString, PROTXML)
self.assertRaisesRegexp(ConfigError, "not found", self.config.parseFromString, URLXML)
