Testing should travel and should fight

CONTRIBUTING.rst

@@ -15,7 +15,7 @@ Types of Contributions
 Report Bugs
 ~~~~~~~~~~~
 
-Report bugs at https://github.com/eeriks/erepublik_script/issues.
+Report bugs at https://github.com/eeriks/erepublik/issues.
 
 If you are reporting a bug, please include:
 
@@ -45,7 +45,7 @@ articles, and such.
 Submit Feedback
 ~~~~~~~~~~~~~~~
 
-The best way to send feedback is to file an issue at https://github.com/eeriks/erepublik_script/issues.
+The best way to send feedback is to file an issue at https://github.com/eeriks/erepublik/issues.
 
 If you are proposing a feature:
 
@@ -62,7 +62,7 @@ Ready to contribute? Here's how to set up `erepublik` for local development.
 1. Fork the `erepublik_script` repo on GitHub.
 2. Clone your fork locally::
 
-    $ git clone git@github.com:your_name_here/erepublik_script.git
+    $ git clone git@github.com:your_name_here/erepublik.git
 
 3. Install your local copy into a virtualenv. Assuming you have virtualenvwrapper installed, this is how you set up your fork for local development::
 

erepublik/citizen.py

@@ -14,8 +14,6 @@ from erepublik import classes, utils
 
 
 class Citizen(classes.CitizenAPI):
-    url: str = "https://www.erepublik.com/en"
-
     division = 0
 
     all_battles: Dict[int, classes.Battle] = None
@@ -47,13 +45,12 @@ class Citizen(classes.CitizenAPI):
 
     r: requests.Response
     reporter: classes.Reporter
-    token = ""
     name = "Not logged in!"
     debug = False
     __registered = False
     logged_in = False
 
-    def __init__(self, email: str = "", password: str = ""):
+    def __init__(self, email: str = "", password: str = "", auto_login: bool = True):
         super().__init__()
         self.commit_id = utils.COMMIT_ID
         self.config = classes.Config()
@@ -65,10 +62,14 @@ class Citizen(classes.CitizenAPI):
         self.my_companies = classes.MyCompanies()
         self.set_debug(True)
         self.reporter = classes.Reporter()
+        self.stop_threads = threading.Event()
+        if auto_login:
+            self.login()
+
+    def login(self):
         self.get_csrf_token()
         self.update_citizen_info()
-        self.reporter.do_init(self.name, email, self.details.citizen_id)
+        self.reporter.do_init(self.name, self.config.email, self.details.citizen_id)
-        self.stop_threads = threading.Event()
         self.__last_full_update = utils.good_timedelta(self.now, - datetime.timedelta(minutes=5))
 
     def write_log(self, *args, **kwargs):
@@ -1324,8 +1325,6 @@ class Citizen(classes.CitizenAPI):
             ret = True
         elif self.should_do_levelup:  # Do levelup
             ret = True
-        elif self.config.all_in and self.energy.available > self.energy.limit * 2 - self.energy.interval * 3:
-            ret = True
         # Get to next Energy +1
         elif self.next_reachable_energy and self.config.next_energy:
             ret = True
@@ -1370,8 +1369,7 @@ class Citizen(classes.CitizenAPI):
             log_msg = "Fighting all-in. Doing %i hits" % count
 
         # All-in for AIR battles
-        elif all([self.config.air, self.config.all_in,
+        elif all([self.config.air, self.config.all_in, self.energy.available >= self.energy.limit]):
-                  self.energy.available >= self.energy.limit]):
             count = self.energy.food_fights
             log_msg = "Fighting all-in in AIR. Doing %i hits" % count
 
@@ -1384,18 +1382,17 @@ class Citizen(classes.CitizenAPI):
         elif self.energy.available + self.energy.interval * 3 >= self.energy.limit * 2:
             count = self.energy.interval
             log_msg = "Fighting for 1h energy. Doing %i hits" % count
+            force_fight = True
 
         if count > 0 and not force_fight:
-            if self.my_companies.ff_lockdown and self.details.pp > 75:
+            if self.energy.food_fights - self.my_companies.ff_lockdown < count and self.details.pp > 75:
-                if self.energy.food_fights - self.my_companies.ff_lockdown < count:
+                log_msg = ("Fight count modified (old count: {} | FF: {} | "
-                    log_msg = ("Fight count modified (old count: {} | FF: {} | "
+                           "WAM ff_lockdown: {} | New count: {})").format(
-                               "WAM ff_lockdown: {} | New count: {})").format(
+                    count, self.energy.food_fights, self.my_companies.ff_lockdown,
-                        count, self.energy.food_fights, self.my_companies.ff_lockdown,
+                    count - self.my_companies.ff_lockdown)
-                        count - self.my_companies.ff_lockdown)
+                count -= self.my_companies.ff_lockdown
-                    count -= self.my_companies.ff_lockdown
-                else:
-                    count = 0
                 if count <= 0:
+                    count = 0
                     log_msg = "Not fighting because WAM needs {} food fights".format(self.my_companies.ff_lockdown)
 
             if self.max_time_till_full_ff > self.time_till_week_change:

erepublik/classes.py

@@ -320,7 +320,7 @@ class Energy:
 
     @property
     def food_fights(self):
-        return (self.recoverable + self.recovered) // 10
+        return self.available // 10
 
     @property
     def reference_time(self):

tests/test_erepublik_script.py

@@ -5,30 +5,153 @@
 
 
 import unittest
-from click.testing import CliRunner
 
 from erepublik import Citizen
-from erepublik import cli
 
 
-class TestErepublik_script(unittest.TestCase):
+class TestErepublik(unittest.TestCase):
     """Tests for `erepublik` package."""
 
     def setUp(self):
         """Set up test fixtures, if any."""
-
+        self.citizen = Citizen("email", "password", False)
-    def tearDown(self):
+        self.citizen.config.interactive = False
-        """Tear down test fixtures, if any."""
 
     def test_000_something(self):
         """Test something."""
 
-    def test_command_line_interface(self):
+    def test_should_do_levelup(self):
-        """Test the CLI."""
+        self.citizen.energy.recovered = 1900
-        runner = CliRunner()
+        self.citizen.energy.recoverable = 2940
-        result = runner.invoke(cli.main)
+        self.citizen.energy.interval = 30
-        assert result.exit_code == 0
+        self.citizen.energy.limit = 3000
-        assert 'erepublik.cli.main' in result.output
+        self.citizen.details.xp = 14850
-        help_result = runner.invoke(cli.main, ['--help'])
+        self.assertTrue(self.citizen.should_do_levelup)
-        assert help_result.exit_code == 0
+
-        assert '--help  Show this message and exit.' in help_result.output
+        self.citizen.energy.recoverable = 1000
+        self.assertFalse(self.citizen.should_do_levelup)
+
+    def test_should_travel_to_fight(self):
+        self.citizen.config.always_travel = True
+        self.assertTrue(self.citizen.should_travel_to_fight())
+        self.citizen.config.always_travel = False
+        self.assertFalse(self.citizen.should_travel_to_fight())
+
+        self.citizen.energy.recovered = 1900
+        self.citizen.energy.recoverable = 2940
+        self.citizen.energy.interval = 30
+        self.citizen.energy.limit = 3000
+        self.citizen.details.xp = 14850
+        self.assertTrue(self.citizen.should_travel_to_fight())
+        self.citizen.details.xp = 15000
+        self.assertFalse(self.citizen.should_travel_to_fight())
+
+        self.citizen.energy.recovered = 3000
+        self.citizen.energy.recoverable = 2910
+        self.assertTrue(self.citizen.should_travel_to_fight())
+        self.citizen.energy.recoverable = 2900
+        self.assertFalse(self.citizen.should_travel_to_fight())
+
+        # self.citizen.next_reachable_energy and self.citizen.config.next_energy
+        self.citizen.config.next_energy = True
+        self.citizen.energy.limit = 5000
+        self.citizen.details.next_pp = [5000, 5250, 5750, 6250, 6750]
+        self.citizen.details.pp = 4900
+        self.citizen.energy.recovered = 4000
+        self.citizen.energy.recoverable = 4510
+        self.assertEqual(self.citizen.next_reachable_energy, 850)
+        self.citizen.energy.recoverable = 4490
+        self.assertTrue(self.citizen.should_travel_to_fight())
+        self.assertEqual(self.citizen.next_reachable_energy, 350)
+        self.citizen.energy.recovered = 100
+        self.citizen.energy.recoverable = 150
+        self.assertFalse(self.citizen.should_travel_to_fight())
+        self.assertEqual(self.citizen.next_reachable_energy, 0)
+
+    def test_should_fight(self):
+        self.citizen.config.fight = False
+        self.assertEqual(self.citizen.should_fight(), 0)
+
+        self.citizen.config.fight = True
+
+
+        # Level up
+        self.citizen.energy.limit = 3000
+        self.citizen.details.xp = 24705
+        self.assertEqual(self.citizen.should_fight(), 0)
+
+        self.citizen.energy.recovered = 3000
+        self.citizen.energy.recoverable = 2950
+        self.citizen.energy.interval = 30
+        self.assertEqual(self.citizen.should_fight(), 895)
+        self.citizen.my_companies.ff_lockdown = 160
+        self.assertEqual(self.citizen.should_fight(), 895)
+        self.citizen.my_companies.ff_lockdown = 0
+
+        # Level up reachable
+        self.citizen.details.xp = 24400
+        self.assertEqual(self.citizen.should_fight(), 305)
+        self.citizen.my_companies.ff_lockdown = 160
+        self.assertEqual(self.citizen.should_fight(), 305)
+        self.citizen.my_companies.ff_lockdown = 0
+
+        self.citizen.details.xp = 21000
+        self.assertEqual(self.citizen.should_fight(), 75)
+        self.citizen.my_companies.ff_lockdown = 160
+        self.assertEqual(self.citizen.should_fight(), 75)
+        self.citizen.my_companies.ff_lockdown = 0
+        self.citizen.details.pp = 80
+
+        # All-in (type = all-in and full ff)
+        self.citizen.config.all_in = True
+        self.assertEqual(self.citizen.should_fight(), 595)
+        self.citizen.my_companies.ff_lockdown = 160
+        self.assertEqual(self.citizen.should_fight(), 435)
+        self.citizen.my_companies.ff_lockdown = 0
+
+        self.citizen.config.air = True
+        self.citizen.energy.recoverable = 1000
+        self.assertEqual(self.citizen.should_fight(), 400)
+        self.citizen.my_companies.ff_lockdown = 160
+        self.assertEqual(self.citizen.should_fight(), 240)
+        self.citizen.my_companies.ff_lockdown = 0
+        self.citizen.config.all_in = False
+
+        self.citizen.config.next_energy = True
+        self.citizen.energy.limit = 5000
+        self.citizen.details.next_pp = [100, 150, 250, 400, 500]
+        self.assertEqual(self.citizen.should_fight(), 320)
+        self.citizen.my_companies.ff_lockdown = 160
+        self.assertEqual(self.citizen.should_fight(), 160)
+        self.citizen.my_companies.ff_lockdown = 0
+        self.citizen.energy.limit = 3000
+        self.citizen.details.next_pp = [19250, 20000]
+        self.citizen.config.next_energy = False
+
+        true = True
+        false = False
+        self.citizen.config.air = True
+        self.citizen.config.all_in = False
+        self.citizen.config.boosters = True
+        self.citizen.config.continuous_fighting = False
+        self.citizen.set_debug(True)
+        self.citizen.config.fight = True
+        self.citizen.config.ground = True
+        self.citizen.config.next_energy = True
+        self.citizen.config.rw_def_side = False
+        self.citizen.config.travel_to_fight = True
+        self.citizen.config.interactive = True
+
+        self.citizen.energy.limit = 1640
+        self.citizen.energy.recoverable = 1640
+        self.citizen.energy.recovered = 1640
+        self.citizen.energy.interval = 44
+        self.citizen.details.xp = 100975
+        self.citizen.details.next_pp = [8750, 9250, 10000]
+        self.citizen.my_companies.ff_lockdown = 9
+        self.assertEqual(self.citizen.should_fight(False), 328)
+
+        # 1h worth of energy
+        self.citizen.energy.recoverable = 2910
+        self.assertEqual(self.citizen.should_fight(), 30)
+