Пример #1
0
 def do_show(self, args):
     '''
         Print the string representation of an instance baed on
         the class name and id given as args.
     '''
     args = shlex.split(args)
     if len(args) == 0:
         print("** class name missing **")
         return
     if len(args) == 1:
         print("** instance id missing **")
         return
     storage = FileStorage()
     storage.reload()
     obj_dict = storage.all()
     try:
         eval(args[0])
     except NameError:
         print("** class doesn't exist **")
         return
     key = args[0] + "." + args[1]
     key = args[0] + "." + args[1]
     try:
         value = obj_dict[key]
         print(value)
     except KeyError:
         print("** no instance found **")
Пример #2
0
    def setUp(self):
        self.store = FileStorage()

        test_args = {'updated_at': datetime(2017, 2, 12, 00, 31, 53, 331997),
                     'id': 'f519fb40-1f5c-458b-945c-2ee8eaaf4900',
                     'created_at': datetime(2017, 2, 12, 00, 31, 53, 331900)}
        self.model = BaseModel(**test_args)

        self.test_len = len(self.store.all())
Пример #3
0
 def do_count(self, args):
     '''
         Counts/retrieves the number of instances.
     '''
     obj_list = []
     storage = FileStorage()
     storage.reload()
     objects = storage.all()
     try:
         if len(args) != 0:
             eval(args)
     except NameError:
         print("** class doesn't exist **")
         return
     for key, val in objects.items():
         if len(args) != 0:
             if type(val) is eval(args):
                 obj_list.append(val)
         else:
             obj_list.append(val)
     print(len(obj_list))
Пример #4
0
 def do_destroy(self, args):
     '''
         Deletes an instance based on the class name and id.
     '''
     args = shlex.split(args)
     if len(args) == 0:
         print("** class name missing **")
         return
     elif len(args) == 1:
         print("** instance id missing **")
         return
     class_name = args[0]
     class_id = args[1]
     storage = FileStorage()
     storage.reload()
     obj_dict = storage.all()
     try:
         eval(class_name)
     except NameError:
         print("** class doesn't exist **")
         return
     key = class_name + "." + class_id
     try:
         del obj_dict[key]
     except KeyError:
         print("** no instance found **")
     storage.save()
Пример #5
0
 def do_update(self, args):
     '''
         Update an instance based on the class name and id
         sent as args.
     '''
     storage = FileStorage()
     storage.reload()
     args = shlex.split(args)
     if len(args) == 0:
         print("** class name missing **")
         return
     elif len(args) == 1:
         print("** instance id missing **")
         return
     elif len(args) == 2:
         print("** attribute name missing **")
         return
     elif len(args) == 3:
         print("** value missing **")
         return
     try:
         eval(args[0])
     except NameError:
         print("** class doesn't exist **")
         return
     key = args[0] + "." + args[1]
     obj_dict = storage.all()
     try:
         obj_value = obj_dict[key]
     except KeyError:
         print("** no instance found **")
         return
     try:
         attr_type = type(getattr(obj_value, args[2]))
         args[3] = attr_type(args[3])
     except AttributeError:
         pass
     setattr(obj_value, args[2], args[3])
     obj_value.save()
Пример #6
0
    def do_all(self, args):
        '''
            Prints all string representation of all instances
            based or not on the class name.
        '''
        obj_list = []
        storage = FileStorage()
        storage.reload()
        objects = storage.all()
        try:
            if len(args) != 0:
                eval(args)
        except NameError:
            print("** class doesn't exist **")
            return
        for key, val in objects.items():
            if len(args) != 0:
                if type(val) is eval(args):
                    obj_list.append(val)
            else:
                obj_list.append(val)

        print(obj_list)
Пример #7
0
#!/usr/bin/python3
"""This module instantiates an object of class FileStorage"""
from os import getenv

if getenv('HBNB_TYPE_STORAGE') == 'db':
    from models.engine.db_storage import DBStorage
    storage = DBStorage()
    storage.reload()
else:
    from models.engine.file_storage import FileStorage
    storage = FileStorage()
    storage.reload()
Пример #8
0
#!/usr/bin/python3
""" TEST TO CHECK COMMENTS """
from models.engine.file_storage import FileStorage


storage = FileStorage()
storage.reload()
Пример #9
0
class Test_FileStorage(unittest.TestCase):
    """
    Test the file storage class
    """
    def setUp(self):
        self.store = FileStorage()

        test_args = {
            'name': 'wifi',
            'updated_at': datetime(2017, 2, 12, 00, 31, 53, 331997),
            'id': 'f519fb40-1f5c-458b-945c-2ee8eaaf4900',
            'created_at': datetime(2017, 2, 12, 00, 31, 53, 331900)
        }
        self.model = Amenity(test_args)
        self.model.save()
        self.test_len = len(self.store.all())

    def tearDown(self):
        self.store.delete(self.model)


#    @classmethod
#    def tearDownClass(cls):
#        import os
#        if os.path.isfile("test_file.json"):
#            os.remove('test_file.json')

    def test_all(self):
        self.assertEqual(len(self.store.all()), self.test_len)

    def test_new(self):
        # note: we cannot assume order of test is order written
        test_len = len(self.store.all())
        # self.assertEqual(len(self.store.all()), self.test_len)
        new_obj = State()
        new_obj.save()
        self.assertEqual(len(self.store.all()), test_len + 1)
        a = BaseModel()
        a.save()
        self.assertEqual(len(self.store.all()), self.test_len + 2)

        self.store.delete(a)
        self.store.delete(new_obj)

    def test_save(self):
        self.test_len = len(self.store.all())
        a = BaseModel()
        a.save()
        self.assertEqual(len(self.store.all()), self.test_len + 1)
        b = User()
        self.assertNotEqual(len(self.store.all()), self.test_len + 2)
        b.save()
        self.assertEqual(len(self.store.all()), self.test_len + 2)

        self.store.delete(a)
        self.store.delete(b)

    def test_reload(self):
        a = BaseModel()
        a.save()
        self.store.reload()
        for value in self.store.all().values():
            self.assertIsInstance(value.created_at, datetime)

        self.store.delete(a)

    def test_state(self):
        """test State creation with an argument"""
        pass

    def test_get(self):
        """Test retrieving an object"""
        my_list = ["name", "id", "created_at", "updated_at"]
        a = self.store.get("Amenity", 'f519fb40-1f5c-458b-945c-2ee8eaaf4900')
        for k in my_list:
            self.assertIsNotNone(getattr(a, k, None))
        self.assertIsNone(getattr(a, "fake_key", None))

        b = self.store.get(None, 'invalid-id')
        self.assertIsNone(b)

        self.store.delete(self.model)

    def test_count(self):
        """Test storage count"""
        self.assertEqual(len(self.store.all()), 1)
        a = Amenity(name="Bob")
        a.save()
        self.assertEqual(len(self.store.all()), 2)

        self.store.delete(a)
Пример #10
0
#!/usr/bin/python3
""" Test delete feature
"""
from models.engine.file_storage import FileStorage
from models.state import State

fs = FileStorage()

# All States
all_states = fs.all(State)
print("All States: {}".format(len(all_states.keys())))
for state_key in all_states.keys():
    print(all_states[state_key])

# Create a new State
new_state = State()
new_state.name = "California"
fs.new(new_state)
fs.save()
print("New State: {}".format(new_state))

# All States
all_states = fs.all(State)
print("All States: {}".format(len(all_states.keys())))
for state_key in all_states.keys():
    print(all_states[state_key])

# Delete the new State
fs.delete(new_state)

# All States
Пример #11
0
 def setUp(self):
     'called multiple times, once before each test'
     self.new_inst = FileStorage()
 def test_FileStorage_instantiation(self):
     """Tests instantiation"""
     temp_storage = FileStorage()
     self.assertIsInstance(temp_storage, FileStorage)
Пример #13
0
class TestFileStorage(unittest.TestCase):
    '''
    class for test of file storage module
    tests for
    all method -- returns dict and format of dict
    new method -- adds new pair to object/file storage instance
    save -- test stoarage and extraction of storage file
    '''
    temp_path = ""
    fs_attr = FileStorage()

    def setUp(self):
        '''init filestorage instance for test case'''
        FileStorage._FileStorage__objects = {}
        TestFileStorage.temp_path = FileStorage._FileStorage__file_path
        FileStorage._FileStorage__file_path = "file.json"

    def tearDown(self):
        '''delete file for filestorage'''
        try:
            os.remove('file.json')
        except:
            pass
        FileStorage._FileStorage__file_path = TestFileStorage.temp_path

    def testAll(self):
        '''
        test all() should return dict
        '''
        test_store = FileStorage()
        new_base = BaseModel()
        test_store.new(new_base)
        self.assertEqual(type(test_store.all()), dict)

    def testDictObj(self):
        '''
        test all() returns valid dict contents
        '''
        new_dict = {
            "BaseModel.1234": {
                "att1": 1,
                "att2": 2
            },
            "BaseModel.4321": {
                "att3": 3,
                "att4": 4
            }
        }
        FileStorage._FileStorage__objects = new_dict
        self.assertEqual(new_dict, TestFileStorage.fs_attr.all())

    def testNew(self):
        '''
        test new() adds pair to storage instance
        '''
        test_s = FileStorage()
        new_base = BaseModel()
        test_s.new(new_base)
        self.assertEqual(type(test_s.all()), dict)
        self.assertEqual(len(test_s.all()), 1)
        self.assertEqual(test_s.all()["BaseModel.{}".format(new_base.id)],
                         new_base)

    def testSave(self):
        '''
        test save() storage
        '''
        new_base1 = BaseModel()
        new_base2 = BaseModel()
        FileStorage().new(new_base1)
        FileStorage().new(new_base2)
        FileStorage().save()
        self.assertTrue(os.path.exists('file.json'))
        with open("file.json", "r") as file:
            self.assertEqual(json.loads(file.read()), {
                key: val.to_dict()
                for key, val in FileStorage().all().items()
            })

    def testRelaod(self):
        '''
        test reload() data can be saved to and loadedfrom json
        '''
        f = storage._FileStorage__file_path
        self.assertFalse(os.path.exists(f))
        storage.reload()
        self.assertFalse(storage.all())
        new_base1 = BaseModel()
        storage.save()
        self.assertTrue(os.path.exists(f))
        with open(f, "r") as file:
            loaded_json = json.load(file)
        cmp_json = {key: val.to_dict() for key, val in storage.all().items()}
        self.assertEqual(cmp_json, loaded_json)
Пример #14
0
 def setUp(self):
     """setup method"""
     self.my_storage = FileStorage()
Пример #15
0
#!/usr/bin/python3
""" Test delete feature
"""
from models.engine.file_storage import FileStorage
from models.state import State

fs = FileStorage()

# All States
print("All States: {}".format(fs.all(State)))

# Create a new State
new_state = State()
new_state.name = "California"
fs.new(new_state)
fs.save()
print("New State: {}".format(fs.all(new_state)))

# All States
print("All States: {}".format(fs.all(State)))

# Delete the new State
fs.delete(new_state)

# All States
print("All States: {}".format(fs.all(State)))
Пример #16
0
class TestFileStorage(unittest.TestCase):

    @classmethod
    def setUpClass(cls):
        """sepup class"""
        print('setupClass')

    @classmethod
    def tearDownClass(cls):
        """teardownclass"""
        print('teardownClass')

    def setUp(self):
        """setup method"""
        self.my_storage = FileStorage()

    def tearDown(self):
        """tearDown"""
        print('tearDown\n')

# ---------------task 5 ----------------
    def test_file_path(self):
        self.assertTrue(isinstance(self.my_storage._FileStorage__file_path, str))

    def test_all(self):
        objects = self.my_storage.all()
        self.assertTrue(isinstance(objects, dict))

    def test_all_not_none(self):
        objects = self.my_storage.all()
        self.assertIsNotNone(objects)

    def test_all_object_attr(self):
        objects = self.my_storage.all()
        self.assertIs(objects, self.my_storage._FileStorage__objects)

    def test_new(self):
        my_base = BaseModel()
        self.my_storage.new(my_base)
        key = my_base.__class__.__name__ + '.' + str(my_base.id)
        self.assertIn(key, self.my_storage._FileStorage__objects.keys())

    def test_save(self):
        my_base = BaseModel()
        self.my_storage.new(my_base)
        self.my_storage.save()
        key = my_base.__class__.__name__ + '.' + my_base.id
        with open("file.json", mode='r') as f:
            my_dict = json.load(f)
        self.assertIn(key, my_dict.keys())

    def test_reload(self):
        my_base = BaseModel()
        self.my_storage.new(my_base)
        self.my_storage.save()
        self.my_storage.reload()
        key = my_base.__class__.__name__ + '.' + my_base.id
        with open("file.json", mode='r') as f:
            my_dict = json.load(f)
        self.assertIn(key, my_dict.keys())

    def test_pep8(self):
        style_test = pep8.StyleGuide(quiet=True).check_files(['models/engine/file_storage.py'])
        self.assertEqual(style_test.total_errors, 0, "Fix pep8 errors")
Пример #17
0
 def test_instantiation(self):
     """
     Tests for proper instantiation
     """
     storage = FileStorage()
     self.assertIsInstance(storage, FileStorage)
 def test_Filestorage_all(self):
     """Tests all method"""
     tmpstor = FileStorage()
     tmpdic = tmpstor.all()
     self.assertIsNotNone(tmpdic)
     self.assertEqual(type(tmpdic), dict)
Пример #19
0
 def setUpClass(cls):
     '''set up before every test method'''
     cls.files1 = FileStorage()
Пример #20
0
 def setUpClass(cls):
     """Set up class before start testing."""
     cls.FS1 = FileStorage()
     cls.FS2 = FileStorage()
Пример #21
0
class Test_FileStorage(unittest.TestCase):
    """
    Test the file storage class
    """

    def setUp(self):
        self.store = FileStorage()

        test_args = {'updated_at': datetime(2017, 2, 12, 00, 31, 53, 331997),
                     'id': 'f519fb40-1f5c-458b-945c-2ee8eaaf4900',
                     'created_at': datetime(2017, 2, 12, 00, 31, 53, 331900)}
        self.model = BaseModel(**test_args)

        self.test_len = len(self.store.all())

#    @classmethod
#    def tearDownClass(cls):
#        import os
#        if os.path.isfile("test_file.json"):
#            os.remove('test_file.json')

    def test_all(self):
        self.assertEqual(len(self.store.all()), self.test_len)

    def test_all_arg(self):
        """test all(State)"""
        new_obj = State()
        new_obj.save()
        everything = self.store.all()
        nb_states = 0
        for e in everything.values():
            if e.__class__.__name__ == "State":
                nb_states += 1
        self.assertEqual(len(self.store.all("State")), nb_states)

# should test with a bad class name

    def test_new(self):
        # note: we cannot assume order of test is order written
        test_len = len(self.store.all())
        # self.assertEqual(len(self.store.all()), self.test_len)
        new_obj = State()
        new_obj.save()
        self.assertEqual(len(self.store.all()), test_len + 1)
        a = BaseModel()
        a.save()
        self.assertEqual(len(self.store.all()), self.test_len + 2)

    def test_save(self):
        self.test_len = len(self.store.all())
        a = BaseModel()
        a.save()
        self.assertEqual(len(self.store.all()), self.test_len + 1)
        b = User()
        self.assertNotEqual(len(self.store.all()), self.test_len + 2)
        b.save()
        self.assertEqual(len(self.store.all()), self.test_len + 2)

    def test_reload(self):
        self.model.save()
        a = BaseModel()
        a.save()
        self.store.reload()
        for value in self.store.all().values():
            self.assertIsInstance(value.created_at, datetime)

    def test_state(self):
        """test State creation with an argument"""
        a = State(name="Kamchatka", id="Kamchatka666")
        a.save()
        self.assertIn("Kamchatka666", self.store.all("State").keys())

    def test_count(self):
        """test count all"""
        test_len = len(self.store.all())
        a = Amenity(name="test_amenity")
        a.save()
        self.assertEqual(test_len + 1, self.store.count())

    def test_count_arg(self):
        """test count with an argument"""
        test_len = len(self.store.all("Amenity"))
        a = Amenity(name="test_amenity_2")
        a.save()
        self.assertEqual(test_len + 1, self.store.count("Amenity"))

    def test_count_bad_arg(self):
        """test count with dummy class name"""
        self.assertEqual(-1, self.store.count("Dummy"))

    def test_get(self):
        """test get with valid cls and id"""
        a = Amenity(name="test_amenity3", id="test_3")
        a.save()
        result = self.store.get("Amenity", "test_3")
        self.assertEqual(a.name, result.name)
        self.assertEqual(a.created_at, result.created_at)

    def test_get_bad_cls(self):
        """test get with invalid cls"""
        result = self.store.get("Dummy", "test")
        self.assertIsNone(result)

    def test_get_bad_id(self):
        """test get with invalid id"""
        result = self.store.get("State", "very_bad_id")
        self.assertIsNone(result)
Пример #22
0
 def setUp(self):
     '''
         Initializing classes
     '''
     self.storage = FileStorage()
     self.my_model = BaseModel()
Пример #23
0
 def setUp(self):
     """Creates FileStorage instance and sets file_path to test.json."""
     self.storage = FileStorage()
     FileStorage._FileStorage__file_path = "test.json"
     FileStorage._FileStorage__objects = {}
     self.storage.reload()
 def test_Filestorage_reload(self):
     """Tests reaload method """
     Bob = FileStorage()
     sizeofobj = len(Bob._FileStorage__objects)
     self.assertGreater(sizeofobj, 0)
Пример #25
0
class TestFileStorage(unittest.TestCase):
    """Defines individual tests for FileStorage."""
    def setUp(self):
        """Creates FileStorage instance and sets file_path to test.json."""
        self.storage = FileStorage()
        FileStorage._FileStorage__file_path = "test.json"
        FileStorage._FileStorage__objects = {}
        self.storage.reload()

    def tearDown(self):
        """Deletes the test json file."""
        if os.path.exists("test.json"):
            os.remove("test.json")

    def test_file_path_exists(self):
        """Tests for __file_path value."""
        self.assertEqual(hasattr(FileStorage, "_FileStorage__file_path"), True)
        self.assertIs(type(FileStorage._FileStorage__file_path), str)

    def test_objects_exists(self):
        """Tests for __objects value."""
        self.assertEqual(hasattr(FileStorage, "_FileStorage__objects"), True)
        self.assertIs(type(FileStorage._FileStorage__objects), dict)
        self.assertEqual(FileStorage._FileStorage__objects, {})

    def test_all_default(self):
        """Tests all with default __objects."""
        self.assertIs(type(self.storage.all()), dict)
        self.assertEqual(self.storage.all(), {})

    def test_all_BaseModel_instance(self):
        """Tests all with one BaseModel instance."""
        instance = BaseModel()
        self.assertIs(type(self.storage.all()), dict)
        self.assertEqual(self.storage.all(),
                         {"BaseModel." + instance.id: instance})

    def test_new(self):
        """Test new with a BaseModel instance."""
        my_dict = {
            "__class__": "BaseModel",
            "id": "5e2d1d8d-92e5-4bc5-ad9a-991ef2268eb8",
            "updated_at": "2019-11-08T23:23:15.141214",
            "created_at": "2019-11-08T23:23:15.141191"
        }
        key = "BaseModel.5e2d1d8d-92e5-4bc5-ad9a-991ef2268eb8"
        instance = BaseModel(**my_dict)
        self.storage.new(instance)
        self.assertIn(key, self.storage.all())
        self.assertIs(self.storage.all()[key], instance)

    def test_save(self):
        """Test save with a BaseModel instance."""
        my_dict = {
            "__class__": "BaseModel",
            "id": "5e2d1d8d-92e5-4bc5-ad9a-991ef2268eb8",
            "updated_at": "2019-11-08T23:23:15.141214",
            "created_at": "2019-11-08T23:23:15.141191"
        }
        key = "BaseModel.5e2d1d8d-92e5-4bc5-ad9a-991ef2268eb8"
        expected = {key: my_dict}
        instance = BaseModel(**my_dict)
        self.storage.new(instance)
        self.storage.save()
        with open("test.json", "r") as f:
            json_dict = json.load(f)
            self.assertEqual(json_dict, expected)

    def test_reload(self):
        """Test save with a BaseModel instance."""
        my_dict = {
            "__class__": "BaseModel",
            "id": "5e2d1d8d-92e5-4bc5-ad9a-991ef2268eb8",
            "updated_at": "2019-11-08T23:23:15.141214",
            "created_at": "2019-11-08T23:23:15.141191"
        }
        key = "BaseModel.5e2d1d8d-92e5-4bc5-ad9a-991ef2268eb8"
        instance = BaseModel(**my_dict)
        self.storage.new(instance)
        self.storage.save()
        self.storage.reload()
        self.assertEqual(len(self.storage.all().keys()), 1)
        self.assertIn(key, self.storage.all())
        self.assertEqual(self.storage.all()[key].to_dict(), my_dict)
Пример #26
0
 def save(self):
     """ save """
     self.updated_at = datetime.now()
     FileStorage.save(None)
Пример #27
0
class testFileStorage(unittest.TestCase):
    '''
        Testing the FileStorage class
    '''

    def setUp(self):
        '''
            Initializing classes
        '''
        self.storage = FileStorage()
        self.my_model = BaseModel()

    def tearDown(self):
        '''
            Cleaning up.
        '''

        try:
            os.remove("file.json")
        except FileNotFoundError:
            pass

    def test_all_return_type(self):
        '''
            Tests the data type of the return value of the all method.
        '''
        storage_all = self.storage.all()
        self.assertIsInstance(storage_all, dict)

    def test_new_method(self):
        '''
            Tests that the new method sets the right key and value pair
            in the FileStorage.__object attribute
        '''
        self.storage.new(self.my_model)
        key = str(self.my_model.__class__.__name__ + "." + self.my_model.id)
        self.assertTrue(key in self.storage._FileStorage__objects)

    def test_objects_value_type(self):
        '''
            Tests that the type of value contained in the FileStorage.__object
            is of type obj.__class__.__name__
        '''
        self.storage.new(self.my_model)
        key = str(self.my_model.__class__.__name__ + "." + self.my_model.id)
        val = self.storage._FileStorage__objects[key]
        self.assertIsInstance(self.my_model, type(val))

    def test_save_file_exists(self):
        '''
            Tests that a file gets created with the name file.json
        '''
        self.storage.save()
        self.assertTrue(os.path.isfile("file.json"))

    def test_save_file_read(self):
        '''
            Testing the contents of the files inside the file.json
        '''
        self.storage.save()
        self.storage.new(self.my_model)

        with open("file.json", encoding="UTF8") as fd:
            content = json.load(fd)

        self.assertTrue(type(content) is dict)

    def test_the_type_file_content(self):
        '''
            testing the type of the contents inside the file.
        '''
        self.storage.save()
        self.storage.new(self.my_model)

        with open("file.json", encoding="UTF8") as fd:
            content = fd.read()

        self.assertIsInstance(content, str)

    def test_reaload_without_file(self):
        '''
            Tests that nothing happens when file.json does not exists
            and reload is called
        '''

        try:
            self.storage.reload()
            self.assertTrue(True)
        except:
            self.assertTrue(False)
Пример #28
0
class Test_console(unittest.TestCase):
    """Test cases for the console.py file
    """
    clis = ['BaseModel', 'User', 'Place', 'City', 'Amenity', 'Review', 'State']
    storage = FileStorage()

    def setUp(self):
        """set environment to start testing"""
        # Empty objects in engine
        FileStorage._FileStorage__objects = {}
        # Remove file.json if exists
        if os.path.exists("file.json"):
            os.remove("file.json")

    def tearDown(self):
        """set enviroment when testing is finished"""
        # Empty objects in engine
        FileStorage._FileStorage__objects = {}
        # Remove file.json if exists
        if os.path.exists("file.json"):
            os.remove("file.json")

    @unittest.skipIf(type_storage == 'db', "No apply for db")
    def test_create(self):
        """Test for create command
        """
        with patch('sys.stdout', new=StringIO()) as f:
            command = "create State name=\"California\""
            HBNBCommand().onecmd(command)
            _id = f.getvalue().strip()
            key = "State" + "." + _id
            self.assertTrue(key in storage.all().keys())

    @unittest.skipIf(type_storage == 'db', "No apply for db")
    def test_create2(self):
        """Test for create command 2
        """
        with patch('sys.stdout', new=StringIO()) as f:
            state = State()
            command = "create City name=\"Texas\" state_id=\"{}\"".format(
                state.id)
            HBNBCommand().onecmd(command)
            _id = f.getvalue().strip()
            key = "City" + "." + _id
            nname = storage.all()[key].name
            sid = storage.all()[key].state_id
            self.assertTrue(key in storage.all().keys())
            self.assertEqual('Texas', nname)
            self.assertEqual(state.id, sid)

    @unittest.skipIf(type_storage == 'db', "No apply for db")
    def test_create3(self):
        """Test for create command 2
        """
        with patch('sys.stdout', new=StringIO()) as f:
            state = State(name='Poloombia')
            command = "create City name=\"Tex_as\" state_id=\"{}\"".format(
                state.id)
            HBNBCommand().onecmd(command)
            _id = f.getvalue().strip()
            key = "City" + "." + _id
            nname = storage.all()[key].name
            sid = storage.all()[key].state_id
            self.assertTrue(key in storage.all().keys())
            self.assertEqual('Tex as', nname)
            self.assertEqual(state.id, sid)
            self.assertEqual('Poloombia', state.name)
Пример #29
0
#!/usr/bin/python3
'''
    Package initializer
'''

from models.engine.file_storage import FileStorage
from models.base_model import BaseModel
from models.user import User
from models.place import Place
from models.state import State
from models.city import City
from models.amenity import Amenity
from models.review import Review

classes = {"User": User, "BaseModel": BaseModel,
           "Place": Place, "State": State,
           "City": City, "Amenity": Amenity,
           "Review": Review}

storage = FileStorage()
storage.reload()
Пример #30
0
 def setUpClass(cls):
     cls.storage = FileStorage()
     cls.storage._FileStorage__objects = {}
     cls.storage._FileStorage__file_path = "atestfile.json"