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)