def test_settings(self): # test some basic settings speedify.packetaggregation(False) speedify.jumbo(False) my_settings = speedify.show_settings() self.assertFalse(my_settings["packetAggregation"]) self.assertFalse(my_settings["jumboPackets"]) speedify.packetaggregation(True) speedify.jumbo(True) my_settings = speedify.show_settings() self.assertTrue(my_settings["packetAggregation"]) self.assertTrue(my_settings["jumboPackets"])
def test_transport(self): mysettings = speedify.transport("https") serverinfo = speedify.connect() mysettings = speedify.show_settings() self.assertEqual(mysettings["transportMode"], "https") # to make sure runtime changed, could check stats and look for connectionstats : connections[] : protocol mysettings = speedify.transport("tcp") self.assertEqual(mysettings["transportMode"], "tcp") serverinfo = speedify.connect() mysettings = speedify.show_settings() self.assertEqual(mysettings["transportMode"], "tcp")
def test_encryption(self): adapters = speedify.show_adapters() self.assertTrue(adapters) # just grab first adapter for testing adapterID = [adapter['adapterID'] for adapter in adapters][0] speedify.adapter_encryption(adapterID, False) mysettings = speedify.show_settings() perConnectionEncryptionEnabled = mysettings[ "perConnectionEncryptionEnabled"] self.assertTrue(perConnectionEncryptionEnabled) encrypted = mysettings["encrypted"] perConnectionEncryptionSettings = mysettings[ "perConnectionEncryptionSettings"] firstadapter = perConnectionEncryptionSettings[0] self.assertEqual(firstadapter["adapterID"], adapterID) self.assertEqual(firstadapter["encrypted"], False) # main thing should still be encrypted just not our one adapter self.assertTrue(encrypted) speedify.encryption(False) #this should both turn off encryption and wipe the custom settings mysettings = speedify.show_settings() perConnectionEncryptionEnabled = mysettings[ "perConnectionEncryptionEnabled"] self.assertFalse(perConnectionEncryptionEnabled) encrypted = mysettings["encrypted"] self.assertFalse(encrypted) # now let's test with only the adapter being encrypted speedify.adapter_encryption(adapterID, True) mysettings = speedify.show_settings() perConnectionEncryptionEnabled = mysettings[ "perConnectionEncryptionEnabled"] self.assertTrue(perConnectionEncryptionEnabled) encrypted = mysettings["encrypted"] perConnectionEncryptionSettings = mysettings[ "perConnectionEncryptionSettings"] firstadapter = perConnectionEncryptionSettings[0] self.assertEqual(firstadapter["adapterID"], adapterID) self.assertEqual(firstadapter["encrypted"], True) speedify.encryption(True) #this should both turn on encryption and wipe the custom settings mysettings = speedify.show_settings() perConnectionEncryptionEnabled = mysettings[ "perConnectionEncryptionEnabled"] self.assertFalse(perConnectionEncryptionEnabled) encrypted = mysettings["encrypted"] self.assertTrue(encrypted)
def test_set_defaults(self): speedify.encryption(False) speedify.transport("tcp") self.assertTrue(speedifysettings.apply_speedify_settings(speedifysettings.speedify_defaults)) settings = speedify.show_settings() self.assertTrue(settings["encrypted"]) self.assertTrue(settings["jumboPackets"]) self.assertEqual( settings["transportMode"] , "auto")
def test_set_json(self): # lets use a settings string to apply it back json_string ='{"encryption" : false, "jumbo" : false, "packet_aggregation":false,"transport":"tcp","adapter_priority_wifi" : "backup"}' self.assertTrue( speedifysettings.apply_speedify_settings(json_string)) settings = speedify.show_settings() self.assertFalse(settings["encrypted"]) self.assertFalse(settings["jumboPackets"]) self.assertFalse(settings["packetAggregation"]) self.assertEqual( settings["transportMode"] , "tcp")
def get_speedify_settings(): ''' Returns the current speedify settings as a dict :returns: dict -- dict of speedify settings ''' settings = {} # pulls out the current settings... couple flaws: # can't get the privacy settings without changing them first, CAN get overflow_threshold # but the other functions can't actually set that. try: adapters = speedify.show_adapters() for adapter in adapters: logging.debug("Adapter is :" + str(adapter)) adaptername = adapter["name"] settings["adapter_ratelimit_" + adaptername] = adapter["rateLimit"] settings["adapter_priority_" + adaptername] = adapter["priority"] if "dataUsage" in adapter: limits = adapter["dataUsage"] if limits: if limits["usageMonthlyLimit"]: settings["adapter_datalimit_monthly_" + adaptername] = limits["usageMonthlyLimit"] if limits["usageDailyLimit"]: settings["adapter_datalimit_daily_" + adaptername] = limits["usageDailyLimit"] currentsettings = speedify.show_settings() logging.debug("Settings are:" + str(currentsettings)) settings["encryption"] = currentsettings["encrypted"] settings["jumbo"] = currentsettings["jumboPackets"] settings["transport"] = currentsettings["transportMode"] settings["startupconnect"] = currentsettings["startupConnect"] settings["mode"] = currentsettings["bondingMode"] settings["overflow_threshold"] = currentsettings["overflowThreshold"] settings["packet_aggregation"] = currentsettings["packetAggregation"] # TODO: can no longer get connectmethod back out! connectmethodsettings = speedify.show_connectmethod() settings["connectmethod"] = connectmethodsettings["connectMethod"] user = speedify.show_user() logging.debug("User is:" + str(user)) privacysettings = speedify.show_privacy() if ("dnsleak" in privacysettings): settings["privacy_dnsleak"] = privacysettings["dnsleak"] if ("killswitch" in privacysettings): settings["privacy_killswitch"] = privacysettings["killswitch"] # CANNOT GET "privacy_dnsleak" or "privacy_killswitch" # without setting on of them except SpeedifyError as se: logging.error("Speedify error on getSpeedfiySetting:" + str(se)) return settings
def test_routedefault(self): speedify.connect() if not speedifyutil.using_speedify(): time.sleep(3) self.assertTrue(speedifyutil.using_speedify()) speedify.routedefault(False) self.assertFalse(speedify.show_settings()["enableDefaultRoute"]) time.sleep(1) if speedifyutil.using_speedify(): # try twice in case it takes a moment to settle time.sleep(1) self.assertFalse(speedifyutil.using_speedify()) speedify.routedefault(True) # for whatever reason getting the route back takes longer than giving it up self.assertTrue(speedify.show_settings()["enableDefaultRoute"]) time.sleep(2) if not speedifyutil.using_speedify(): # try twice in case it takes a moment to settle time.sleep(2) self.assertTrue(speedifyutil.using_speedify())
def get_team_settings(locked, exportadapters): ''' Returns the current speedify settings as a dict :returns: dict -- dict of speedify settings ''' # The tree where we build our export settingsExport = {} try: currentsettings = speedify.show_settings() if exportadapters: adapters = speedify.show_adapters() #TODO: perConnectionEncryptionSettings #perConnectionEncryptionSettings = {} #settingsExport["perConnectionEncryptionSettings"] = perConnectionEncryptionSettings; prioritiesExport = { "Wi-Fi": { "value": "always", "locked": locked }, "Ethernet": { "value": "always", "locked": locked }, "Unknown": { "value": "always", "locked": locked }, "Cellular": { "value": "secondary", "locked": locked } } settingsExport["priorities"] = prioritiesExport ratelimitExport = { "Wi-Fi": { "value": 0, "locked": locked }, "Ethernet": { "value": 0, "locked": locked }, "Unknown": { "value": 0, "locked": locked }, "Cellular": { "value": 0, "locked": locked } } settingsExport["rateLimit"] = ratelimitExport monthlyLimitExport = { "Wi-Fi": { "value": { "monthlyLimit": 0, "monthlyResetDay": 0 }, "locked": locked }, "Ethernet": { "value": { "monthlyLimit": 0, "monthlyResetDay": 0 }, "locked": locked }, "Unknown": { "value": { "monthlyLimit": 0, "monthlyResetDay": 0 }, "locked": locked }, "Cellular": { "value": { "monthlyLimit": 0, "monthlyResetDay": 0 }, "locked": locked } } dailyLimitExport = { "Wi-Fi": { "value": 0, "locked": locked }, "Ethernet": { "value": 0, "locked": locked }, "Unknown": { "value": 0, "locked": locked }, "Cellular": { "value": 0, "locked": locked } } overlimitRateLimitExport = { "Wi-Fi": { "value": 0, "locked": locked }, "Ethernet": { "value": 0, "locked": locked }, "Unknown": { "value": 0, "locked": locked }, "Cellular": { "value": 0, "locked": locked } } settingsExport["overlimitRateLimit"] = overlimitRateLimitExport encyptdefault = currentsettings["encrypted"] perConnectionEncryptionSettingExport = { "Wi-Fi": { "value": encyptdefault, "locked": locked }, "Ethernet": { "value": encyptdefault, "locked": locked }, "Unknown": { "value": encyptdefault, "locked": locked }, "Cellular": { "value": encyptdefault, "locked": locked } } perConnectionEncryptionSettings = currentsettings[ "perConnectionEncryptionSettings"] anyperconnection = False anylimits = False for adapter in adapters: logging.debug("Adapter is :" + str(adapter)) adaptertype = adapter["type"] # everything is keyed on adapter type, if you have # more than one adapter with same type, one of them # will get overwritten by the other. for perConnectionEncryptionSetting in perConnectionEncryptionSettings: # the per connection encryption is tucked into settings instead of adapters, # but you still need to look in adapters to find the adaptertype if perConnectionEncryptionSetting["adapterID"] == adapter[ "adapterID"]: encryptExport = {} encryptExport[ "value"] = perConnectionEncryptionSetting[ "encrypted"] encryptExport["locked"] = locked anyperconnection = True perConnectionEncryptionSettingExport[ adaptertype] = encryptExport ratelimitExport[adaptertype] = {} ratelimitExport[adaptertype]["value"] = adapter["rateLimit"] ratelimitExport[adaptertype]["locked"] = locked prioritiesExport[adaptertype] = {} prioritiesExport[adaptertype]["value"] = adapter["priority"] prioritiesExport[adaptertype]["locked"] = locked if "dataUsage" in adapter: limits = adapter["dataUsage"] anylimits = True monthlyLimitExport[adaptertype] = {} monthlyLimitExport[adaptertype]["value"] = {} monthlyLimitExport[adaptertype]["value"][ "monthlyLimit"] = limits["usageMonthlyLimit"] monthlyLimitExport[adaptertype]["value"][ "monthlyResetDay"] = limits["usageMonthlyResetDay"] monthlyLimitExport[adaptertype]["locked"] = locked dailyLimitExport[adaptertype] = {} dailyLimitExport[adaptertype]["value"] = limits[ "usageDailyLimit"] dailyLimitExport[adaptertype]["locked"] = locked overlimitRateLimitExport[adaptertype] = {} overlimitRateLimitExport[adaptertype]["value"] = limits[ "overlimitRatelimit"] overlimitRateLimitExport[adaptertype]["locked"] = locked # add optional sections only if they have something if anyperconnection: settingsExport[ "perConnectionEncryptionSetting"] = perConnectionEncryptionSettingExport if anylimits: settingsExport["monthlyLimit"] = monthlyLimitExport settingsExport["dailyLimit"] = dailyLimitExport # done with adapters logging.debug("Settings are:" + str(currentsettings)) settingsExport["encrypted"] = {} settingsExport["encrypted"]["value"] = currentsettings["encrypted"] settingsExport["encrypted"]["locked"] = locked settingsExport["jumboPackets"] = {} settingsExport["jumboPackets"]["value"] = currentsettings[ "jumboPackets"] settingsExport["jumboPackets"]["locked"] = locked settingsExport["transportMode"] = {} settingsExport["transportMode"]["value"] = currentsettings[ "transportMode"] settingsExport["transportMode"]["locked"] = locked settingsExport["startupConnect"] = {} settingsExport["startupConnect"]["value"] = currentsettings[ "startupConnect"] settingsExport["startupConnect"]["locked"] = locked settingsExport["bondingMode"] = {} settingsExport["bondingMode"]["value"] = currentsettings["bondingMode"] settingsExport["bondingMode"]["locked"] = locked settingsExport["overflowThreshold"] = {} settingsExport["overflowThreshold"]["value"] = currentsettings[ "overflowThreshold"] settingsExport["overflowThreshold"]["locked"] = locked settingsExport["packetAggregation"] = {} settingsExport["packetAggregation"]["value"] = currentsettings[ "packetAggregation"] settingsExport["packetAggregation"]["locked"] = locked settingsExport["allowChaChaEncryption"] = {} settingsExport["allowChaChaEncryption"]["value"] = currentsettings[ "allowChaChaEncryption"] settingsExport["allowChaChaEncryption"]["locked"] = locked connectmethodsettings = speedify.show_connectmethod() settingsExport["connectMethod"] = {} settingsExport["connectMethod"][ "value"] = speedify.connectmethod_as_string(connectmethodsettings) settingsExport["connectMethod"]["locked"] = locked if "forwardedPorts" in currentsettings: forwardedPortsExport = {} forwardedPortsExport["locked"] = locked forwardedPortsExport["value"] = [] forwardedPortSettings = currentsettings["forwardedPorts"] for portInfo in forwardedPortSettings: newPortExport = {} newPortExport["port"] = portInfo["port"] newPortExport["proto"] = portInfo["protocol"] forwardedPortsExport["value"].append(newPortExport) settingsExport["forwardedPorts"] = forwardedPortsExport privacysettings = speedify.show_privacy() if "dnsLeak" in privacysettings: settingsExport["dnsleak"] = {} settingsExport["dnsleak"]["value"] = privacysettings["dnsleak"] settingsExport["dnsleak"]["locked"] = locked if "killswitch" in privacysettings: settingsExport["killswitch"] = {} settingsExport["killswitch"]["value"] = privacysettings[ "killswitch"] settingsExport["killswitch"]["locked"] = locked if "dnsAddresses" in privacysettings: settingsExport["dnsAddresses"] = {} settingsExport["dnsAddresses"]["locked"] = locked settingsExport["dnsAddresses"]["value"] = [] for dnsserver in privacysettings["dnsAddresses"]: settingsExport["dnsAddresses"]["value"].append(dnsserver) settingsExport["crashReports"] = {} settingsExport["crashReports"]["value"] = privacysettings[ "crashReports"] settingsExport["crashReports"]["locked"] = locked except SpeedifyError as se: logging.error("Speedify error on getTeamSetting:" + str(se)) jsonExport = {} jsonExport["settings"] = settingsExport return jsonExport