def test_load_uwp(self): '''Test create with UWP''' planet = LBB6Planet(uwp='B433432-A') self.assertTrue(str(planet) == 'B433432-A') planet = LBB6Planet(uwp='YS00000-0') self.assertTrue(str(planet) == 'YS00000-0')
def test_non_hz_orbits(self): '''Test non-HZ orbits (hydrographics)''' star = Star('G2 V') planet = LBB6Planet() planet.generate(star=star, orbit=Orbit(1)) self.assertTrue(int(planet.hydrographics) == 0) planet = LBB6Planet() planet.generate(star=star, orbit=Orbit(11)) self.assertTrue(str(planet.atmosphere) in '0A')
def test_create(self): '''Basic create tests''' planet = LBB6Planet() planet.generate() self.assertTrue(isinstance(planet, LBB6Planet)) self.assertTrue(planet.starport in 'ABCDEX') # Not mainworld planet = LBB6Planet() planet.generate(is_mainworld=False) self.assertTrue(planet.starport in 'FGHY')
def test_albedo_land_coverage(self): ''' Test albedo land coverage desert_coverage = 10% * (10 - hydrographics) Modifiers: - Vacuum/trace atmosphere => desert_coverage = 100% - Very thin atmosphere => desert_coverage +10% - Thin atmosphere => desert_coverage +5% - Dense atmosphere => desert_coverage -5% ''' planet = LBB6Planet() for hyd in range(0, 11): for atm in range(0, 10): expected = float((10 - hyd)) * 0.1 if atm <= 1: expected = 1.0 if atm >= 2 and atm <= 3: expected += 0.1 if atm >= 4 and atm <= 5: expected += 0.05 if atm >= 8 and atm <= 9: expected -= 0.05 if hyd == 0: expected = 1.0 expected = round(expected, 2) expected = min(1.0, expected) expected = max(0.0, expected) planet.hydrographics = ehex(hyd) planet.atmosphere = ehex(atm) desert_coverage = planet._albedo_determine_desert_coverage() LOGGER.debug('uwp %s expected = %s actual = %s', str(planet), expected, desert_coverage) self.assertTrue(expected == desert_coverage)
def test_va(self): '''Test Va trade code''' planet = LBB6Planet() planet.atmosphere = ehex(0) planet._determine_env_trade_codes() LOGGER.debug('planet = %s', str(planet)) self.assertTrue('Va' in planet.trade_codes)
def test_temperature(self): '''Temperature tests''' star = Star('G2 V') for test in [{ 'uwp': 'A867A69-F', 'orbit': 3, 'expected': MinMax(221.0, 303.0) }, { 'uwp': 'F20067C-F', 'orbit': 3, 'expected': MinMax(299.0, 299.0) }, { 'uwp': 'F43056A-F', 'orbit': 4, 'expected': MinMax(237.0, 237.0) }, { 'uwp': 'G8B0168-F', 'orbit': 2, 'expected': MinMax(300.0, 707.0) }, { 'uwp': 'F10046C-F', 'orbit': 9, 'expected': MinMax(48.0, 48.0) }]: planet = LBB6Planet(uwp=test['uwp']) planet.generate(star=star, orbit=Orbit(test['orbit'])) LOGGER.debug('planet = %s', planet.json()) LOGGER.debug('uwp = %s expected = %s, actual = %s', test['uwp'], test['expected'], planet.temperature) self.assertAlmostEqual(planet.temperature.min(), test['expected'].min(), delta=2) self.assertAlmostEqual(planet.temperature.max(), test['expected'].max(), delta=2)
def test_as(self): '''Test As trade code''' planet = LBB6Planet() planet.is_mainworld = True planet.atmosphere = ehex(0) planet._determine_env_trade_codes() LOGGER.debug('planet = %s', str(planet)) self.assertTrue('As' in planet.trade_codes)
def test_not_va(self): '''Test !Va trade code''' planet = LBB6Planet() for atm in '123456789ABC': planet.atmosphere = ehex(atm) planet._determine_env_trade_codes() LOGGER.debug('planet = %s', str(planet)) self.assertFalse('Va' in planet.trade_codes)
def test_not_wa(self): '''Test !Wa trade code''' planet = LBB6Planet() for hyd in '0123456789': planet.hydrographics = ehex(hyd) planet._determine_env_trade_codes() LOGGER.debug('planet = %s', str(planet)) self.assertFalse('Wa' in planet.trade_codes)
def test_albedo_ice_no_hz(self): '''Ensure star.hz_orbit being None doesn't raise exception''' star = Star('MD') orbit = Orbit(3) planet = LBB6Planet(uwp='X644000-0') planet.generate(star=star, orbit=orbit) self.assertTrue(planet._determine_albedo_ice_coverage() == float( int(planet.hydrographics) / 10.0))
def test_create(self, mock_fn): '''Create tests''' mainworld = LBB6Planet(uwp='A788767-8') parent = LBB6ExpandedStar(mainworld) companion = LBB6CompanionStar(parent) LOGGER.debug('companion = %s', str(companion)) self.assertTrue(companion.type == 'K') self.assertTrue(companion.size == 'V')
def test_not_as(self): '''Test !As trade code''' planet = LBB6Planet() planet.is_mainworld = False for atm in '0123456789ABC': planet.atmosphere = ehex(atm) planet._determine_env_trade_codes() LOGGER.debug('planet = %s', str(planet)) self.assertFalse('As' in planet.trade_codes)
def test_de(self): '''Test De trade code''' planet = LBB6Planet() planet.hydrographics = ehex(0) for atm in '23456789ABC': planet.atmosphere = ehex(atm) planet._determine_env_trade_codes() LOGGER.debug('planet = %s', str(planet)) self.assertTrue('De' in planet.trade_codes)
def test_create_roll1s(self, mock_fn): '''Create tests, roll 1 every time''' planet = LBB6Planet() # Size 0, not mainworld => size = S planet.generate(is_mainworld=False) LOGGER.debug('planet = %s', str(planet)) self.assertTrue(planet.size == 'S') # Size 0, mainworld => size = 0 planet.generate(is_mainworld=True) self.assertTrue(planet.size == '0')
def test_not_ic(self): '''Test !Ic trade code''' planet = LBB6Planet() for atm in '23456789ABC': for hyd in '0123456789A': planet.atmosphere = ehex(atm) planet.hydrographics = ehex(hyd) planet._determine_env_trade_codes() LOGGER.debug('planet = %s', str(planet)) self.assertFalse('Ic' in planet.trade_codes)
def test_temperature_formula(self): '''Test temperature formula''' temp = LBB6Planet._temperature_formula( 1.0, # Luminosity 0.3, # Albedo 1.0, # Distance (AU) 1.1 # Greenhouse effect ) LOGGER.debug('temp = %s', temp) self.assertTrue(temp == 288)
def on_get(self, req, resp): '''GET <apiserver>/ct/lbb6/planet?uwp=<uwp>&<<options>>''' self.query_parameters = { 'doc': False, 'uwp': None, 'orbit_no': None, 'star': None, 'name': None, 'is_mainworld': True } self.parse_query_string(req.query_string) LOGGER.debug('querystring = %s', req.query_string) LOGGER.debug('is_mainworld = %s', self.query_parameters['is_mainworld']) if self.query_parameters['doc'] is True: resp.body = self.get_doc_json(req) resp.status = falcon.HTTP_200 else: # Anything to do? if self.query_parameters['uwp'] is None: raise falcon.HTTPError(title='Invalid UWP', status='400 Invalid parameter', description='No UWP specified') # Star? if self.query_parameters['star'] is not None: self.query_parameters['star'] = \ catch_html_space(self.query_parameters['star']) star = self.get_star_details() else: star = None # Orbit? if self.query_parameters['orbit_no'] is not None: orbit = self.get_orbit_details(star) else: orbit = None try: planet = LBB6Planet(uwp=self.query_parameters['uwp'], name=self.query_parameters['name']) LOGGER.debug('query_param is_mainworld = %s', self.query_parameters['is_mainworld']) planet.generate( star=star, orbit=orbit, is_mainworld=self.query_parameters['is_mainworld']) except ValueError as err: raise falcon.HTTPError(title='Invalid planet', status='400 Invalid parameter', description=str(err)) resp.body = planet.json() resp.status = falcon.HTTP_200
def test_create_random(self, mock_fn): '''Test codeless create''' # This mainworld gets a +4 on size and type rolls mainworld = LBB6Planet(uwp='A788767-8') LOGGER.debug('mainworld type = %s', type(mainworld)) star = LBB6ExpandedStar(mainworld) self.assertTrue(star.type == 'M') self.assertTrue(star.size == 'V') LOGGER.debug('star.size_roll = %s, star.type_roll = %s', star.size_roll, star.type_roll) self.assertTrue(star.size_roll == 6) self.assertTrue(star.type_roll == 6)
def test_albedo(self): '''Albedo tests''' star = Star('G2 V') tests = [{ 'uwp': 'A867977-8', 'star': star, 'orbit': Orbit(3), 'expected': (0.265, 0.465) }] for test in tests: planet = LBB6Planet(uwp=test['uwp']) planet.generate(star=test['star'], orbit=test['orbit']) LOGGER.debug('uwp = %s TCs = %s albedo = %s', str(planet), planet.trade_codes, str(planet.albedo)) self.assertTrue(planet.albedo.min() == test['expected'][0]) self.assertTrue(planet.albedo.max() == test['expected'][1])
def test_albedo_ice_coverage(self): ''' Test albedo_ice_coverage Inner zone => ice_coverage = 0% HZ => ice_coverage == 10% Outer zone => ice_coverage = hydrographics Can't find orbit or star => ice_coverage = 10% ''' planet = LBB6Planet(uwp='X644000-0') # Inner zone planet.generate(star=Star('G2 V'), orbit=Orbit(1)) self.assertTrue(planet._determine_albedo_ice_coverage() == 0.0) # Habitable zone planet.generate(star=Star('G2 V'), orbit=Orbit(3)) self.assertTrue(planet._determine_albedo_ice_coverage() == 0.1) # Outer zone planet.generate(star=Star('G2 V'), orbit=Orbit(5)) for hyd in range(0, 11): planet.hydrographics = ehex(hyd) self.assertTrue( planet._determine_albedo_ice_coverage() == float(hyd / 10.0))
def test_json(self, mock_fn): '''Test JSON representation''' # No orbit or star expected = json.dumps( { "is_mainworld": True, "name": "", "orbit": None, "orbital_period": None, "star": None, "temperature": { "max": None, "min": None }, "temperature_factors": { "albedo": { "max": 0.266, "min": 0.226 }, "cloudiness": 0.1, 'greenhouse': { "max": 1.0, "min": 1.0 } }, "trade_codes": ["Ni", "Po"], "uwp": "B433432-A" }, sort_keys=True) planet = LBB6Planet(uwp='B433432-A') planet.generate() LOGGER.debug('expected = %s', expected) LOGGER.debug('planet.json() = %s', planet.json()) self.assertTrue(planet.json() == expected) # Orbit, star expected = json.dumps( { "is_mainworld": True, "name": "Planet 9", "orbit": "Orbit 3: 1.0 AU, 149.6 Mkm", "orbital_period": None, "star": "G2 V", "temperature": { "max": 289.0, "min": 274.0 }, "temperature_factors": { "albedo": { "max": 0.266, "min": 0.226 }, "cloudiness": 0.1, 'greenhouse': { "max": 1.0, "min": 1.0 } }, "trade_codes": ["Ni", "Po"], "uwp": "B433432-A" }, sort_keys=True) planet = LBB6Planet('Planet 9', uwp='B433432-A') planet.generate(star=Star('G2 V'), orbit=Orbit(3)) LOGGER.debug('expected = %s', expected) LOGGER.debug('planet.json() = %s', planet.json()) self.assertTrue(planet.json() == expected)
def test_wa(self): '''Test Wa trade code''' planet = LBB6Planet() planet.hydrographics = ehex('A') planet._determine_env_trade_codes() self.assertTrue('Wa' in planet.trade_codes)
def test_greenhouse(self): '''Greenhouse tests''' planet = LBB6Planet() tests = [ { 'atm': '0', 'expected': 1.0 }, { 'atm': '1', 'expected': 1.0 }, { 'atm': '2', 'expected': 1.0 }, { 'atm': '3', 'expected': 1.0 }, { 'atm': '4', 'expected': 1.05 }, { 'atm': '5', 'expected': 1.05 }, { 'atm': '6', 'expected': 1.1 }, { 'atm': '7', 'expected': 1.1 }, { 'atm': '8', 'expected': 1.15 }, { 'atm': '9', 'expected': 1.15 }, { 'atm': 'A', 'expected': (1.2, 1.7) }, { 'atm': 'B', 'expected': (1.2, 2.2) }, { 'atm': 'C', 'expected': (1.2, 2.2) }, { 'atm': 'D', 'expected': 1.15 }, { 'atm': 'E', 'expected': 1.1 }, { 'atm': 'F', 'expected': 1.0 }, ] for test in tests: planet.atmosphere = ehex(test['atm']) planet.determine_greenhouse() LOGGER.debug('atm = %s expected = %s planet = %s, result = %s', test['atm'], test['expected'], str(planet), planet.greenhouse.dict()) if isinstance(test['expected'], tuple): # pragma pylint: disable=E1136 self.assertTrue(planet.greenhouse.min() == test['expected'][0]) self.assertTrue(planet.greenhouse.max() == test['expected'][1]) else: self.assertTrue(planet.greenhouse.min() == test['expected']) self.assertTrue(planet.greenhouse.max() == test['expected'])
def test_cloudiness(self): ''' Cloudiness tests hyd 0-1: cloudiness = 0% hyd 2-3: cloudiness = 10% hyd 4: cloudiness = 20% hyd 5: cloudiness = 30% hyd 6: cloudiness = 40% hyd 7: cloudiness = 50% hyd 8: cloudiness = 60% hyd 9-A: cloudiness = 70% atm A+: cloudiness +40% atm 3-: max cloudiness = 20% atm E: cloudiness / 2 ''' test_cases = [{ 'hyd': '0', 'cloudiness': 0.0 }, { 'hyd': '1', 'cloudiness': 0.0 }, { 'hyd': '2', 'cloudiness': 0.1 }, { 'hyd': '3', 'cloudiness': 0.1 }, { 'hyd': '4', 'cloudiness': 0.2 }, { 'hyd': '5', 'cloudiness': 0.3 }, { 'hyd': '6', 'cloudiness': 0.4 }, { 'hyd': '7', 'cloudiness': 0.5 }, { 'hyd': '8', 'cloudiness': 0.6 }, { 'hyd': '9', 'cloudiness': 0.7 }, { 'hyd': 'A', 'cloudiness': 0.7 }] planet = LBB6Planet() for test in test_cases: planet.hydrographics = ehex(test['hyd']) for atm in '0123456789ABCDEF': planet.atmosphere = ehex(atm) expected = test['cloudiness'] if atm in '0123': expected = min(expected, 0.2) if atm in 'ABCDEF': expected += 0.4 expected = min(expected, 1.0) if atm == 'E': expected = expected / 2.0 expected = round(expected, 1) planet.determine_cloudiness() LOGGER.debug( 'hyd = %s, atm = %s, cloudiness = %s, expected = %s', planet.hydrographics, planet.atmosphere, planet.cloudiness, expected) self.assertTrue(planet.cloudiness == expected)