def test_ship_creation(self):
user = User('user', Color.RED)
start_planet = Planet(1, 25, 25, 2, user, None)
destination_planet = Planet(2, 100, 100, 2, user, None)
ship = Ship((1, 1), start_planet, destination_planet)
self.assertEqual(ship.owner, user)
self.assertEqual(ship.color, Color.RED)
def db_seed():
mercury = Planet(planet_name='Mercury',
planet_type='Class D',
home_star='sol',
mass=3.258e23,
radius=1516,
distance=35.98e6)
venus = Planet(planet_name='Venus',
planet_type='Class k',
home_star='sol',
mass=4.867e24,
radius=3760,
distance=67.24e6)
earth = Planet(planet_name='Earth',
planet_type='Class M',
home_star='sol',
mass=5.972e24,
radius=3959,
distance=92.96e6)
db.session.add(mercury)
db.session.add(venus)
db.session.add(earth)
test_user = User(first_name='William',
last_name='Herschel',
email='*****@*****.**',
password='******')
db.session.add(test_user)
db.session.commit()
print('Database Seeded!')
def test_create_action(self):
state = State(
planets={
0: Planet(x=-10, y=1),
1: Planet(x=10, y=2),
2: Planet(x=0, y=10),
},
hyperlanes={
(0, 1): Hyperlane(origin=0, target=1),
(1, 0): Hyperlane(origin=1, target=0),
},
)
valid_actions = {
(-10, 1, 10, 2),
(10, 2, -10, 1),
}
invalid_actions = {
(-10, 1, 0, 10),
(0, 10, -10, 1),
(0, 10, 10, 2),
(10, 2, 0, 10),
}
self.assertFalse(valid_actions.intersection(invalid_actions))
for _ in range(100):
action = create_action(state, correct=True)
self.assertIn(action, valid_actions)
for _ in range(100):
action = create_action(state, correct=False)
self.assertIn(action, invalid_actions)
def test_send_ships(self):
planet = Planet(1, 100, 100, 20, User('user', Color.RED), None)
destination_planet = Planet(2, 300, 300, 20, User('user', Color.RED),
None)
game = GameView(20, 20, None, User('user', Color.RED), None)
num_ships = planet.units.count // 2
units_start = planet.units.count
planet.send_ships(game, destination_planet, 1 / 2)
self.assertEqual(planet.units.count, units_start - num_ships)
def generate_mocked_planets(self, player, enemies):
planets = []
# for current player
planets.append(Planet(1, 100, 100, randint(30, 60), player, self))
planets.append(Planet(2, 400, 200, randint(30, 60), player, self))
# for enemies
planets.append(Planet(3, 720, 200, randint(30, 100), enemies[0], self))
planets.append(Planet(3, 850, 600, randint(30, 100), enemies[1], self))
return planets
def initialize_planets_2d(self, ratio):
num_planets = self.size**2 / ratio
planet_locations = set([])
planets = []
while len(planets) < num_planets:
coords = (random.randrange(0, self.size),
random.randrange(0, self.size))
coords_str = "{},{}".format(*coords)
if coords_str in planet_locations:
continue
planet = Planet(self.get_random_name(), random.randrange(10, 1000),
coords[0], coords[1])
planets.append({'obj': planet, 'location': coords})
with self.app.app_context():
for planet in planets:
db.session.add(planet['obj'])
db.session.commit()
for planet in planets:
location_dict = {
'planet': planet['obj'].id,
'ships': [],
}
key = self._build_coordinate_key(planet['location'])
self.redis.set(key, json.dumps(location_dict))
self.planets = {
p['obj'].id: {
'location': p['location']
}
for p in planets
}
self.redis.set(self.planets_key, json.dumps(self.planets))
def list_addAll():
body = request.get_json()
people = body['character']
planet = body['planet']
vehicles = body['starship']
for c in character:
character1 = Character(name=c["Character Name"],
heigth=c["Character heigth"],
mass=c["Character mass"],
hair_color=c["Character hair color"],
skin_color=c["Character skin color"],
gender=c["Character Gender"])
db.session.add(character1)
for p in planet:
planet1 = Planet(name=p["Name"],
diameter=p["Diameter"],
climate=p["Climate"],
gravity=p["Gravity"],
population=p["Population"])
db.session.add(planet1)
for s in starship:
starships1 = Starship(name=s["Vehicle name"],
model=s["Model"],
passengers=serialize["Passengers"],
consumable=s["consumable"],
cargo_capacity=s["Cargo capacity"],
hyperdrive_rating=s["Hyperdrive rating"])
db.session.add(starship1)
db.session.commit()
def create_planet():
request_body = request.get_json()
planet = Planet(name=request_body["name"], climate=request_body["climate"], orbital_period=request_body["orbita_period"], population=request_body["population"], rotation_period=request_body["rotation_period"], gravity=request_body["gravity"])
db.session.add(planet)
db.session.commit()
print("Planet created: ", request_body)
return jsonify(request_body), 200
def create_planet():
name = request.json.get('name')
diameter = request.json.get('diameter')
rotation_period = request.json.get('rotation_period')
orbital_period = request.json.get('orbital_period')
gravity = request.json.get('gravity')
population = request.json.get('population')
climate = request.json.get('climate')
terrain = request.json.get('terrain')
surface_water = request.json.get('surface_water')
created = request.json.get('created')
edited = request.json.get('edited')
if not name:
return jsonify({"Mensaje": "El nombre no puede estar vacio"})
new_planet = Planet()
new_planet.name = name
new_planet.diameter = diameter
new_planet.rotation_period = rotation_period
new_planet.orbital_period = orbital_period
new_planet.gravity = gravity
new_planet.population = population
new_planet.climate = climate
new_planet.terrain = terrain
new_planet.surface_water = surface_water
db.session.add(new_planet)
db.session.commit()
return jsonify({"Mensaje": "Planeta creado exitosamente"}), 201
def add_planet():
planet_name = request.form['planet_name']
test = Planet.query.filter_by(planet_name=planet_name).first()
if test:
return jsonify(message='That planet already exists'), 409
else:
# below line commented since it's already requested above
# planet_name = request.form['planet_name']
planet_type = request.form['planet_type']
home_star = request.form['home_star']
mass = float(request.form['mass'])
radius = float(request.form['radius'])
distance = float(request.form['distance'])
# SQLAlchemy
new_planet = Planet(planet_name=planet_name,
planet_type=planet_type,
home_star=home_star,
mass=mass,
radius=radius,
distance=distance)
db.session.add(new_planet)
db.session.commit()
return jsonify(message='You added a planet!'), 201
def test_planet_last_ship_to_cap_arrival(self):
user = User('user', Color.RED)
planet = Planet(1, 25, 25, 1, user, None)
user2 = User('user2', Color.BLUE)
planet.arrival(user2)
self.assertEqual(planet.owner, user2)
self.assertEqual(planet.units.count, 1)
def test_planet_owner_ship_arrival(self):
user = User('user', Color.RED)
planet = Planet(1, 25, 25, 20, user, None)
units_count = planet.units.count
planet.arrival(user)
self.assertEqual(planet.units.count, units_count + 1)
self.assertEqual(planet.owner, user)
def test_planet_cap(self):
user1 = User('user', Color.RED)
planet = Planet(1, 25, 25, 20, user1, None)
user2 = User('user', Color.BLUE)
planet.cap(user2)
self.assertNotEqual(planet.owner, user1)
self.assertEqual(planet.owner, user2)
def test_planet_units_genetation(self):
user = User('user', Color.RED)
planet = Planet(1, 25, 25, 2, user, None)
unit_count = planet.units.count
planet.units.update()
self.assertEqual(
planet.units.count,
unit_count + planet.radius * planet.units.generation_coef)
def create_planet():
request_body_planet = request.get_json()
newPlanet = Planet(planet_name=request_body_planet["planet_name"], population=request_body_planet["population"], terrain=request_body_planet["terrain"])
db.session.add(newPlanet)
db.session.commit()
return jsonify(request_body_planet), 200
def test_planet_creation(self):
user = User('user', Color.RED)
planet = Planet(1, 25, 25, 20, user, None)
self.assertTrue(planet.units is not None)
self.assertEqual(planet.spawnRate, 4)
self.assertEqual(planet.owner, user)
self.assertEqual(planet.capped, False)
self.assertNotEqual(planet.img, None)
self.assertNotEqual(planet.rect, None)
def seed():
if os.getenv('env') == "docker":
db = connect('planets', host="mongo")
else:
db = connect('planets')
db.drop_database('planets') # CLEARS DATABASE FOR TESTING
# POPULATING DATA WITH EXAMPLES
tatooine = Planet(name='dagobah', terrain='swamp', climate='murky',
appearances=3)
tatooine.save()
hoth = Planet(name='hoth', terrain='tundra', climate='cold',
appearances=1)
hoth.save()
print('examples added to the database')
def test_sent(self):
init_state = State(hyperlanes={
(0, 1): Hyperlane(origin=0, target=1),
(1, 0): Hyperlane(origin=1, target=0)
},
planets={
0:
Planet(owner=1,
ships=(1, 2, 3),
production=(1, 5, 6)),
1:
Planet()
})
state = attach_action(init_state, 'send 0 1 1 3 2\n')
self.assertEqual(state.planets, init_state.planets)
self.assertEqual(
state.hyperlanes, {
(0, 1): Hyperlane(origin=0, target=1, action=(1, 3, 2)),
(1, 0): Hyperlane(origin=1, target=0)
})
def add_planet():
# recibir info del request
request_body = request.get_json()
print(request_body)
new_planet = Planet(name=request_body["name"], climate=request_body["climate"], diameter=request_body["diameter"],
gravity=request_body["gravity"], population=request_body["population"], terrain=request_body["terrain"])
db.session.add(new_planet)
db.session.commit()
return jsonify("All good, added: ", new_planet.serialize()), 200
def planets(id=None):
if request.method == 'GET':
if id is not None:
planet = Planet.query.get(id)
if not planet:
return jsonify({"fail": "Planet not found"}), 404
return jsonify({
"success": "Planet found",
"planet": planet.serialize()
}), 200
else:
planets = Planet.query.all()
planets = list(map(lambda planet: planet.serialize(), planets))
return jsonify({
"total": len(planets),
"results": planets
}), 200
if request.method == 'POST':
name = request.json.get('name')
population = request.json.get('population')
terrain = request.json.get('terrain')
climate = request.json.get('climate')
rotation_period = request.json.get('rotation_period')
orbital_period = request.json.get('orbital_period')
gravity = request.json.get('gravity')
planet = Planet()
planet.name = name
planet.population = population
planet.terrain = terrain
planet.climate = climate
planet.rotation_period = rotation_period
planet.orbital_period = orbital_period
planet.gravity = gravity
planet.save()
return jsonify({
"success": "planet created!",
"planet": planet.serialize()
}), 201
if request.method == 'PUT':
pass
if request.method == 'DELETE':
planet = Planet.query.get(id)
if not planet:
return jsonify({"fail": "planet not found"}), 404
planet.delete()
return jsonify({"success": "planet deleted"}), 200
def createPlanet():
planet = Planet()
planet.name = request.json.get('name')
planet.rotation_period = request.json.get('rotation_period')
planet.orbital_period = request.json.get('orbital_period')
planet.diameter = request.json.get('diameter')
planet.climate = request.json.get('climate')
planet.gravity = request.json.get('gravity')
planet.terrain = request.json.get('terrain')
planet.surface_water = request.json.get('surface_water')
planet.population = request.json.get('population')
planet.save()
return jsonify(planet.to_dict()), 201
def seed():
mercury = Planet(planet_name="Mercury",
planet_type="Class D",
home_star="Sol",
mass=3.258e23,
radius=1516,
distance=35.98e6)
venus = Planet(planet_name="Venus",
planet_type="Class K",
home_star="Sol",
mass=4.867e24,
radius=3760,
distance=67.24e6)
earth = Planet(planet_name="Earth",
planet_type="Class M",
home_star="Sol",
mass=5.972e24,
radius=3959,
distance=92.96e6)
john = User(fname='John',
lname='Smith',
email='*****@*****.**',
password='******')
leon = User(fname='Leaon',
lname='Eric',
email='*****@*****.**',
password='******')
session.add(mercury)
session.add(venus)
session.add(earth)
session.add(john)
session.add(leon)
session.commit() # saving changes to db
print("Rows added successfully to db")
def setUp(self):
self.planets = {
1:
Planet(owner=1,
x=2,
y=3,
ships=(3, 2, 1),
production=(6, 5, 1),
production_rounds_left=2),
0:
Planet(owner=0, x=4, y=6, ships=(4, 5, 6))
}
self.fleets = [
Fleet( # The only and the one
owner=2,
origin=1,
target=0,
ships=(3, 2, 1),
eta=5),
]
self.hyperlanes = {
(1, 0): Hyperlane(origin=1, target=0, fleets=(self.fleets[0], )),
(0, 1): Hyperlane(origin=0, target=1),
}
def Planet_agregar():
name = request.json.get("name", None)
diametro = request.json.get("diametro", None)
rotation = request.json.get("rotation", None)
poblacion = request.json.get("poblacion", None)
terreno = request.json.get("terreno", None)
planet = Planet(name=name,
diametro=diametro,
rotation=rotation,
poblacion=poblacion,
terreno=terreno)
db.session.add(planet)
db.session.commit()
#user=json.loads(name, color_ojos, color_cabello,gender)
return jsonify({"planet": "ok"})
def post(self):
try:
result = PlanetSchema().load(request.json)
newplanet = Planet(**result)
if Planet.objects(name__iexact=newplanet.name):
return ApiResponseBuilder.error(
'this planet is already in the database', 404)
newplanet.get_appearances()
newplanet.save()
except ma_exc.ValidationError as err:
return ApiResponseBuilder.error(err.messages, 400)
return ApiResponseBuilder.success(
f'planet named {newplanet.name} was added successfully',
newplanet.serialized, 201)
def get_planets():
count = get_count('planets')
for planet_id in range(1, count + 1):
url = SWAPI_URL.format('planets') + '{}/'.format(planet_id)
planet = None
try:
planet = DB.open().query(Planet).filter(
Planet.api_url == url).one()
except:
obj = get_request(url)
if 'name' in obj:
planet = Planet()
planet.parse_json(obj)
DB.save(planet)
if planet:
print(planet.name)
print('+++++++++++++++++')
def list_addAll():
body = request.get_json()
people = body["people"]
planet = body["planet"]
vehicle = body["vehicle"]
for p in people:
people1 = People(
name=p["Character name"],
height=p["Character height"],
mass=p["Character mass"],
hair_color=p["Character hair_color"],
skin_color=p["Character skin color"],
eye_color=p["Character eye color"],
birth_year=p["Character birth year"],
gender=p["Character gender"],
)
db.session.add(people1)
for pl in planet:
planet1 = Planet(
planet_name=pl["Planet name"],
rotation_period=pl["Rotation period"],
orbital_period=pl["Orbital period"],
diameter=pl["Diameter"],
climate=pl["Climate"],
gravity=pl["Gravity"],
terrain=pl["Terrain"],
population=pl["Population"],
)
db.session.add(planet1)
for v in planet:
vehicle1 = Vehicle(
vehicle_name=v["Vehicle name"],
model=v["Model"],
passenger=v["Passenger"],
consumable=v["Consumable"],
starship_class=v["Starship class"],
lenght=v["Lenght"],
cargo_capacity=v["Cargo capacity"],
hyperdrive_rating=v["Hyperdrive rating"],
)
db.session.add(vehicle1)
db.session.commit()
def add_planet():
planet_name = request.json['planet_name']
test = Planet.query.filter_by(planet_name=planet_name).first()
if test:
return jsonify("There is already planet by that name."), 409
else:
planet_type = request.json['planet_type']
home_star = request.json['home_star']
mass = float(request.json['mass'])
radius = float(request.json['radius'])
distance = float(request.json['distance'])
new_planet = Planet(planet_name=planet_name,
planet_type=planet_type,
home_star=home_star,
mass=mass,
radius=radius,
distance=distance)
db.session.add(new_planet)
db.session.commit()
return jsonify(message="You added a planet"), 201
def addAll():
body = request.get_json()
people = body['people']
planet = body['planet']
vehicle = body['vehicle']
for p in people:
people1 = People(name=p["Character Name"],
height=p["Character height"],
mass=p["Character mass"],
hair_color=p["Character hair color"],
skin_color=p["Character skin color"],
eye_color=p["Character eye color"],
birth_year=p["Character birth year"],
gender=p["Character gender"])
db.session.add(people1)
for p in planet:
planet1 = Planet(planet_name=pl["Planet name"],
rotation_period=pl["rotation period"],
orbital_period=pl["orbital period"],
diameter=pl["diameter"],
climate=pl["climate"],
gravity=pl["gravity"],
terrain=pl["terrain"],
population=pl["population"])
db.session.add(planet1)
for p in vehicle:
vehicle1 = Vehicle(vehicle_name=v["vehicle name"],
model=v["model"],
passenger=v["passenger"],
consumable=v["consumable"],
starship_class=v["starship class"],
lenght=v["lenght"],
cargo_capacity=v["cargo capacity"],
hyperdrive_rating=v["hyperdrive rating"])
db.session.add(vehicle1)
db.session.commit()
def add_planets():
all_planets = []
for i in range(1, 11):
planets = requests.get(f"https://www.swapi.tech/api/planets/{i}").json(
)["result"]["properties"]
all_planets.append(planets)
for request_body in all_planets:
planet = Planet(name=request_body["name"],
climate=request_body["climate"],
population=request_body["population"],
orbital_period=request_body["orbital_period"],
rotation_period=request_body["rotation_period"],
diameter=request_body["diameter"],
gravity=request_body["gravity"],
terrain=request_body["terrain"],
surface_water=request_body["surface_water"],
edited=request_body["edited"],
created=request_body["created"],
url=request_body["url"])
db.session.add(planet)
db.session.commit()
return jsonify({"msg": "Planets added"}), 200
