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_json(self):
'''Test JSON representation'''
# Test with star specfied
expected = json.dumps(
{
"angular_diameter": 0.522,
"au": 1,
"mkm": 149.6,
"notes": [],
"orbit_no": 3,
"period": 1.0,
"star": "G2 V"
},
sort_keys=True)
orbit = Orbit(3, Star('G2 V'))
LOGGER.debug('orbit.json() = %s', orbit.json())
self.assertTrue(orbit.json() == expected)
# Test, no star
expected = json.dumps(
{
"angular_diameter": None,
"au": 1,
"mkm": 149.6,
"notes": [],
"orbit_no": 3,
"period": None,
"star": None
},
sort_keys=True)
orbit = Orbit(3)
LOGGER.debug('orbit.json() = %s', orbit.json())
self.assertTrue(orbit.json() == expected)
def test_creates(self):
'''Test making orbit, valid and invalid values'''
for orbit_no in [0, 19]:
orbit = Orbit(orbit_no)
self.assertTrue(orbit_no == orbit.orbit_no)
self.assertTrue(orbit.period is None)
orbit = Orbit(3, Star('G2 V'))
self.assertTrue(orbit.orbit_no == 3)
self.assertTrue(str(orbit.star) == 'G2 V')
self.assertTrue(orbit.period == 1.0)
# Bogus creates
for orbit_no in ['foo', -1, 25]:
with self.assertRaises(ValueError):
_ = Orbit(orbit_no)
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_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_unavailable_orbits(self):
'''Test for interior orbit, mnimum orbit'''
# Interior orbit
orbit = Orbit(2, Star('M9 Ia'))
LOGGER.debug('notes = %s', orbit.notes)
self.assertTrue(
'Orbit 2 is within M9 Ia star; minimum orbit is 8' in \
orbit.notes
)
# Minimum orbit
orbit = Orbit(2, Star('B5 V'))
LOGGER.debug('notes = %s', orbit.notes)
self.assertTrue(
'Orbit 2 is unavailable to B5 V star; minimum orbit is 3' in \
orbit.notes
)
# Edge case: orbit == minimum_orbit
orbit = Orbit(0, Star('G2 V'))
LOGGER.debug('notes = %s', orbit.notes)
self.assertTrue(orbit.notes == [])
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 on_get(self, req, resp):
'''GET <apiserver>/ct/lbb6/orbit?orbit_no=<orbit>&star=<code>'''
self.query_parameters = {'doc': False, 'orbit_no': None, 'star': None}
self.parse_query_string(req.query_string)
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['orbit_no'] is None:
raise falcon.HTTPError(title='Invalid orbit',
status='400 Invalid parameter',
description='No orbit specified')
# Star? If yes, retrieve star data into Star object
if self.query_parameters['star'] is not None:
try:
self.query_parameters['star'] = \
catch_html_space(self.query_parameters['star'])
star = StarData(self.query_parameters['star'])
except ValueError as err:
raise falcon.HTTPError(
title='Invalid star',
status='400 Invalid parameter',
description='Invalid star {}'.format(
self.query_parameters['star']))
else:
star = None
try:
orbit = OrbitData(self.query_parameters['orbit_no'], star)
except ValueError as err:
raise falcon.HTTPError(title='Invalid orbit',
status='400 Invalid parameter',
description=str(err))
resp.body = orbit.json()
resp.status = falcon.HTTP_200
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_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_str(self):
'''Test str() representation'''
orbit = Orbit(3)
LOGGER.debug('str(orbit) = %s', str(orbit))
self.assertTrue(str(orbit) == 'Orbit 3: 1.0 AU, 149.6 Mkm')
def test_angdia(self, mock_fn):
'''Test angdia response if API server is down'''
orbit = Orbit(3, Star('G2 V'))
self.assertTrue(
'Unable to connect to API endpoint http://api.trav.phraction.org'
in orbit.notes)
def test_period_calc(self):
'''Test period calculation'''
orbit = Orbit(3, Star('G2 V'))
self.assertTrue(orbit.period == 1.0)
orbit = Orbit(2)
self.assertTrue(orbit.period is None)