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",