def test_view_one_city_wrong(self):
"""the id does not match a city"""
city_args = {"name": "Gaborone", "id": "GA", "state_id": "BO"}
city = City(**city_args)
city.save()
rv = self.app.get('{}/cities/{}/'.format(self.path, "noID"),
follow_redirects=True)
self.assertEqual(rv.status_code, 404)
storage.delete(city)
def test_getcities_badstate(self):
"""test listing all cities with a bad state id"""
city_args = {"name": "Gaborone", "id": "GA", "state_id": "BO"}
city = City(**city_args)
city.save()
rv = self.app.get('{}/states/{}/cities'.format(self.path, "noID"),
follow_redirects=True)
self.assertEqual(rv.status_code, 404)
storage.delete(city)
def test_update_city_bad_id(self):
"""test update with no matching id"""
city_args = {"name": "Gaborone", "id": "GA", "state_id": "BO"}
city = City(**city_args)
city.save()
rv = self.app.put('{}/cities/{}/'.format(self.path, "noID"),
content_type="application/json",
data=json.dumps({"name": "Z"}),
follow_redirects=True)
self.assertEqual(rv.status_code, 404)
storage.delete(city)
def test_update_city_bad_json(self):
"""test update with ill formedt json"""
city_args = {"name": "Gaborone", "id": "GA", "state_id": "BO"}
city = City(**city_args)
city.save()
rv = self.app.put('{}/cities/{}/'.format(self.path, city.id),
content_type="application/json",
data={"id": "Z"},
follow_redirects=True)
self.assertEqual(rv.status_code, 400)
self.assertEqual(rv.get_data(), b"Not a JSON")
storage.delete(city)
def test_view_one_city(self):
"""test retrieving one state"""
city_args = {"name": "Gaborone", "id": "GA", "state_id": "BO"}
city = City(**city_args)
city.save()
rv = self.app.get('{}/cities/{}'.format(self.path, city_args["id"]),
follow_redirects=True)
self.assertEqual(rv.status_code, 200)
self.assertEqual(rv.headers.get("Content-Type"), "application/json")
json_format = getJson(rv)
self.assertEqual(json_format.get("name"), city_args["name"])
self.assertEqual(json_format.get("id"), city_args["id"])
storage.delete(city)
def test_delete_city(self):
"""test delete a city"""
city_args = {"name": "Gaborone", "id": "GA", "state_id": "BO"}
city = City(**city_args)
city.save()
rv = self.app.delete('{}/cities/{}/'.format(self.path,
city_args["id"]),
follow_redirects=True)
self.assertEqual(rv.status_code, 200)
self.assertEqual(rv.headers.get("Content-Type"), "application/json")
json_format = getJson(rv)
self.assertEqual(json_format, {})
self.assertIsNone(storage.get("City", city_args["id"]))
class ExtendedTestCase(unittest.TestCase):
public_app = TestApp(public_main.createApp())
admin_app = TestApp(admin_main.createApp())
_login_stubs = StubOutForTesting()
stubs = StubOutForTesting()
def random(self):
import hashlib, time
return hashlib.md5((time.clock()*random.random()).__str__()).hexdigest()
def setUp(self):
self.make_test_data()
self.login()
self.mox = Mox()
def tearDown(self):
self.logout()
self.stubs.UnsetAll()
for model in [City, Company, Performance, Show, Venue]:
for datum in model.all():
datum.delete()
def login(self, user="******", admin=True):
self._login_stubs.Set(users, 'get_current_user', lambda user = user : users.User(user))
self._login_stubs.Set(users, 'is_current_user_admin', lambda admin = admin : admin)
def logout(self):
self._login_stubs.UnsetAll()
def make_test_data(self):
now = datetime.datetime.now()
self.now = datetime.datetime(year = now.date().year, month = now.date().month, day = now.date().day, hour = now.time().hour, minute = now.time().minute)
self.one_day_later = self.now + datetime.timedelta(days=1)
self.two_days_later = self.now + datetime.timedelta(days=2)
self.three_days_later = self.now + datetime.timedelta(days=3)
self.evam = Company(name='Evam Theatre Company', url='evam')
self.evam.put()
self.hamlet = Show(name='Hamlet', url='hamlet', company=self.evam)
self.hamlet.put()
self.chennai = City(name='Chennai', url='chennai')
self.chennai.put()
self.bangalore = City(name='Bangalore', url='bangalore')
self.bangalore.put()
self.lady_andal = Venue(name='Lady Andal', url='lady_andal', city=self.chennai)
self.lady_andal.put()
def make_performance(self, show, venue, dt):
perf = Performance(show=show, venue=venue, utc_date_time=dt)
perf.put()
return perf
def test_getcities(self):
"""test listing all cities"""
city_args = {"name": "Gaborone", "id": "GA", "state_id": "BO"}
city = City(**city_args)
city.save()
rv = self.app.get('{}/states/{}/cities'.format(
self.path, self.state.id),
follow_redirects=True)
self.assertEqual(rv.status_code, 200)
self.assertEqual(rv.headers.get("Content-Type"), "application/json")
json_format = getJson(rv)
self.assertTrue(type(json_format), list)
self.assertIn(city_args["name"], [e.get("name") for e in json_format])
storage.delete(city)
def test_update_city_state_id(self):
"""test cannot update city state_id"""
city_args = {"name": "Gaborone", "id": "GA", "state_id": "BO"}
city = City(**city_args)
city.save()
rv = self.app.put('{}/cities/{}/'.format(self.path, city.id),
content_type="application/json",
data=json.dumps({"state_id": "Z"}),
follow_redirects=True)
self.assertEqual(rv.status_code, 200)
self.assertEqual(rv.headers.get("Content-Type"), "application/json")
json_format = getJson(rv)
self.assertEqual(json_format.get("name"), city_args["name"])
self.assertEqual(json_format.get("id"), city_args["id"])
self.assertEqual(json_format.get("state_id"), city_args["state_id"])
storage.delete(city)
def test_city_deletion(self):
city_route = '/_admin/city'
url = self.random()
City(name = self.random(), url = url, hours = 5, minutes = 45).put()
city_data = dict(action='delete')
self.admin_app.post(city_route+'/'+url, city_data)
self.assertFalse(City.get_by_url(url))
def update(self, city_url=None):
current_city = City.get_by_url(city_url)
current_city.name = self.read('name')
current_city.url = self.read('url')
current_city.hours_offset = int(self.read('hours'))
current_city.minutes_offset = int(self.read('minutes'))
current_city.put()
self.redirect('/_admin/city', False)
def make_test_data(self):
now = datetime.datetime.now()
self.now = datetime.datetime(year = now.date().year, month = now.date().month, day = now.date().day, hour = now.time().hour, minute = now.time().minute)
self.one_day_later = self.now + datetime.timedelta(days=1)
self.two_days_later = self.now + datetime.timedelta(days=2)
self.three_days_later = self.now + datetime.timedelta(days=3)
self.evam = Company(name='Evam Theatre Company', url='evam')
self.evam.put()
self.hamlet = Show(name='Hamlet', url='hamlet', company=self.evam)
self.hamlet.put()
self.chennai = City(name='Chennai', url='chennai')
self.chennai.put()
self.bangalore = City(name='Bangalore', url='bangalore')
self.bangalore.put()
self.lady_andal = Venue(name='Lady Andal', url='lady_andal', city=self.chennai)
self.lady_andal.put()
def get(self, city_url, venue_url):
redirect_url = None
city = City.get_by_url(city_url)
if city: venue = city.get_venue_by_url(venue_url)
else: redirect_url = '/'
if not venue: redirect_url = '/' + city_url
if not redirect_url:
performances = venue.get_performances().fetch(50)
self.render('public/venue.html', dict(venue=venue,
performances=performances,
auth = utils.authdetails(venue.get_route())))
else:
self.redirect(redirect_url,False)
def test_city_creation(self):
city_route = '/_admin/city'
self.admin_app.post(city_route, {'action':'create'}, status=403) # tells blank posts to bugger off
name = self.random()
url = self.random()
city_data = dict(action='create', name=name, url=url, hours=5, minutes=43)
self.admin_app.post(city_route, city_data)
self.admin_app.post(city_route, city_data, status=403) # create the city only once
city = City.get_by_url(url)
self.assertTrue(city)
self.assertEqual(name, city.name)
self.assertEqual(url, city.url)
def get(self, url):
city = City.get_by_url(url)
if not city: company = Company.get_by_url(url)
if not city and not company:
self.redirect('/', False)
return
data_type = 'city' if city else 'company'
data = city or company
start_after = self.read('start_after')
performances = data.get_performances(start_after = start_after).fetch(PAGE+1)
start_after = performances[-2].time_sort if len(performances) == PAGE+1 else None
render_data = dict(performances=performances[:PAGE],
start_after = start_after,
auth = utils.authdetails(data.get_route()))
render_data[data_type] = data
self.render('public/' + data_type + '.html', render_data)
def test_city_updating(self):
city_route = '/_admin/city'
self.admin_app.post(city_route, {'action':'update'}, status=403) # tells blank posts to bugger off
url = self.random()
City(name = self.random(), url = url, hours = 5, minutes = 45).put()
new_name = self.random()
new_hours = 6
new_minutes = 34
new_url = self.random()
city_data = dict(action='update', name=new_name, url=new_url, hours=new_hours, minutes=new_minutes)
self.admin_app.post(city_route+'/'+url, city_data)
city = City.get_by_url(new_url)
self.assertTrue(city)
self.assertEqual(new_name, city.name)
self.assertEqual(new_url, city.url)
self.assertEqual(new_hours, city.hours_offset)
self.assertEqual(new_minutes, city.minutes_offset)
def setUpClass(cls):
"""Set up class before start testing."""
cls.C1 = City()
cls.C2 = City()
def put(self):
if City.get_by_url(self.url): raise ValueError('This url is being used by a city')
return super(Company, self).put()
def setUp(self):
self.Rome = City('Rome', 2014)
self.Paris = City('Paris', 2014)
self.USA = City('Washington D.C.', 2016)
def test_save_with_arg(self):
cy = City()
with self.assertRaises(TypeError):
cy.save(None)
def test_to_dict_type(self):
self.assertTrue(dict, type(City().to_dict()))
def test_to_dict_contains_added_attributes(self):
cy = City()
cy.middle_name = "Holberton"
cy.my_number = 98
self.assertEqual("Holberton", cy.middle_name)
self.assertIn("my_number", cy.to_dict())
def delete(self, city_url=None):
city = City.get_by_url(city_url)
if city: city.delete()
self.get()
def test_two_cities_different_updated_at(self):
cy1 = City()
sleep(0.05)
cy2 = City()
self.assertLess(cy1.updated_at, cy2.updated_at)
def test_two_cities_unique_ids(self):
cy1 = City()
cy2 = City()
self.assertNotEqual(cy1.id, cy2.id)
def test_name_is_public_class_attribute(self):
cy = City()
self.assertEqual(str, type(City.name))
self.assertIn("name", dir(cy))
self.assertNotIn("name", cy.__dict__)
def test_state_id_is_public_class_attribute(self):
cy = City()
self.assertEqual(str, type(City.state_id))
self.assertIn("state_id", dir(cy))
self.assertNotIn("state_id", cy.__dict__)
def test_updated_at_is_public_datetime(self):
self.assertEqual(datetime, type(City().updated_at))
def test_id_is_public_str(self):
self.assertEqual(str, type(City().id))
def test_new_instance_stored_in_objects(self):
self.assertIn(City(), models.storage.all().values())
def test_city_creation_with_duplicate_urls_fails(self):
url = self.random()
city1 = City(name="some city", url=url)
city1.put()
city2 = City(name="some other city", url=url)
self.assertRaises(ValueError, city2.put)
def test_no_args_instantiates(self):
self.assertEqual(City, type(City()))
def test_contrast_to_dict_dunder_dict(self):
cy = City()
self.assertNotEqual(cy.to_dict(), cy.__dict__)
def get(self, city_url=None):
current_city = City.get_by_url(city_url)
self.render("admin/city.html", dict(cities=City.all(), current_city=current_city))
def setUp(cls):
"""creates class"""
cls.testCity = City()
cls.testCity.name = "test"
cls.testCity.state_id = "T"
def test_to_dict_contains_correct_keys(self):
cy = City()
self.assertIn("id", cy.to_dict())
self.assertIn("created_at", cy.to_dict())
self.assertIn("updated_at", cy.to_dict())
self.assertIn("__class__", cy.to_dict())
def test_attributes(self):
""" Test default value """
c1 = City()
self.assertEqual(c1.state_id, "")
self.assertEqual(c1.name, "")
def test_save_updates_file(self):
cy = City()
cy.save()
cyid = "City." + cy.id
with open("file.json", "r") as f:
self.assertIn(cyid, f.read())
def test_id(self):
""" Test id """
c1 = City()
c2 = City()
self.assertNotEqual(c1.id, c2.id)
def test_one_save(self):
cy = City()
sleep(0.05)
first_updated_at = cy.updated_at
cy.save()
self.assertLess(first_updated_at, cy.updated_at)
def test_attr(self):
""" Test naming """
c1 = City()
c1.name = "NYC"
self.assertEqual(c1.name, "NYC")
""" Test link Many-To-Many Place <> Amenity """ from models import * from models.user import User from models.state import State from models.city import City from models.amenity import Amenity from models.place import Place from models.review import Review # creation of a State state = State(name="California") state.save() # creation of a City city = City(state_id=state.id, name="San Francisco") city.save() # creation of a User user = User(email="*****@*****.**", password="******") user.save() # creation of 2 Places place_1 = Place(user_id=user.id, city_id=city.id, name="House 1") place_1.save() place_2 = Place(user_id=user.id, city_id=city.id, name="House 2") place_2.save() # creation of 3 various Amenity amenity_1 = Amenity(name="Wifi") amenity_1.save()
def check_city(self):
city = City.get_by_url(self.read('city'))
if not city: raise Exception("That city doesn't exist.")
return city
def setUpClass(cls):
"""set up for test"""
cls.city = City()
cls.city.name = "LA"
cls.city.state_id = "CA"
def get(self, venue_url = None):
self.render('admin/venue.html', dict(cities=City.all(), current_venue = Venue.get_by_url(venue_url)))
def setUp(self):
"""Sets up test methods."""
FileStorage._FileStorage__file_path = "test_json"
self.city = City()
self.city.name = "Bogota"
self.city.save()
def test_to_dict_datetime_attributes_are_strs(self):
cy = City()
cy_dict = cy.to_dict()
self.assertEqual(str, type(cy_dict["id"]))
self.assertEqual(str, type(cy_dict["created_at"]))
self.assertEqual(str, type(cy_dict["updated_at"]))
def test_args_unused(self):
cy = City(None)
self.assertNotIn(None, cy.__dict__.values())
def test_to_dict_with_arg(self):
cy = City()
with self.assertRaises(TypeError):
cy.to_dict(None)
def test_instantiation_with_None_kwargs(self):
with self.assertRaises(TypeError):
City(id=None, created_at=None, updated_at=None)
def test_City(self):
""" Check if loads name """
city = City(name="Bogota")
if city.id in models.storage.all():
self.assertTrue(city.name, "Bogota")
def get(self):
self.render('public/home.html', dict(cities = City.all()))
#!/usr/bin/python3
from models import storage
from models.city import City
from models.venue import Venue
from models.show import Show
from models.artist import Artist
from models.social_organizer import SocialOrganizer
from models.social_artist import SocialArtist
from models.organizer import Organizer
from werkzeug.security import generate_password_hash, check_password_hash
# Create city
city = City(city_name='Bogotá', country_name="Colombia", state="Bogotá DC")
city.save()
pwd = 'pwd'
pwd_md5 = generate_password_hash(pwd)
organizer = Organizer(names_organizer="Rock al Parque",
email="*****@*****.**", pwd=pwd_md5)
organizer.save()
# social object
print(organizer.id)
social_1 = SocialOrganizer(organizer_id=organizer.id)
print(social_1)
social_1.save()
# create venue
venue = {"city_id": city.id, "venue_name": "venue_1",
"address": "Calle del cartucho", "capacity": 150, "phone": "23555"}
venue_2 = {"city_id": city.id, "venue_name": "venue_2",
