コード例 #1
0
class PostgresNoSQLViewTest(unittest.TestCase):
    def setUp(self):
        self.client = PostgresNoSQLClient(host=TEST_DB_HOST, user=TEST_DB_USER, password=TEST_DB_PASSWORD)

        # pre cleanup
        if self.client.database_exists(TEST_DATABASE):
            self.client.drop_database(TEST_DATABASE)

        self.database = self.client.create_database(TEST_DATABASE)
        self.user = self.database.create_table('users', name='text')
        self.info = self.database.create_table('info', fk_user='******', age='integer')

        # fill table with data
        self.user.insert(name='Simon')
        self.user.insert(name='Felix')
        self.info.insert(fk_user=1, age=30)
        self.info.insert(fk_user=2, age=40)

        # create view
        self.database.execute('CREATE VIEW user_view AS SELECT users.name, info.age FROM users JOIN info ON users.id = info.fk_user')

        # get view
        self.user_view = self.database.get_view('user_view')

    def tearDown(self):
        # cleanup
        if self.database is not None:
            self.database.close()

        if self.client.database_exists(self.database.name):
            self.client.drop_database(self.database.name)

    def test_query_view(self):
        records = self.user_view.query()
        self.assertEqual(2, len(records))
コード例 #2
0
class PostgresNoSQLResultItemTest(unittest.TestCase):
    def setUp(self):
        self.client = PostgresNoSQLClient(host=TEST_DB_HOST, user=TEST_DB_USER, password=TEST_DB_PASSWORD)

        # pre cleanup
        if self.client.database_exists(TEST_DATABASE):
            self.client.drop_database(TEST_DATABASE)

        self.database = self.client.create_database(TEST_DATABASE)
        self.table = self.database.create_table(TEST_TABLE)
        self.relational_table = self.database.create_table(TEST_RELATIONAL_TABLE, **RELATIONAL_FIELDS)

        # fill table
        self.first = self.table.put(JSON_DATA)
        self.first_relational = self.relational_table.put(JSON_DATA, **RELATIONAL_DATA)

    def tearDown(self):
        # cleanup
        if self.database is not None:
            self.database.close()

        if self.client.database_exists(self.database.name):
            self.client.drop_database(self.database.name)

    def test_json_serialize(self):
        record = self.table.get(self.first)
        # todo: useless unit test atm
        json_string = json.dumps(record.get_record())
        self.assertEqual(json.dumps(record.get_record()), json_string)
コード例 #3
0
class PostgresNoSQLDatabaseTest(unittest.TestCase):

    def setUp(self):
        self.client = PostgresNoSQLClient(host=TEST_DB_HOST, user=TEST_DB_USER, password=TEST_DB_PASSWORD)

        # pre cleanup
        if self.client.database_exists(TEST_DATABASE):
            self.client.drop_database(TEST_DATABASE)

        self.database = self.client.create_database(TEST_DATABASE)
        self.table = self.database.create_table(TEST_TABLE)

    def tearDown(self):
        # cleanup
        if self.database is not None:
            self.database.close()

        if self.client.database_exists(self.database.name):
            self.client.drop_database(self.database.name)

        self.database = None
        self.table = None
        self.client = None

    def test_table_exists(self):
        self.assertEqual(True, self.database.table_exists(TEST_TABLE))
        self.assertEqual(False, self.database.table_exists(TEST_TABLE+'12345'))

    def test_get_table_with_existing(self):
        self.assertNotEqual(None, self.database.get_table(TEST_TABLE))

    def test_get_table_without_existing(self):
        self.assertEqual(None, self.database.get_table(TEST_TABLE+'12345'))

    def test_create_table(self):
        temp = self.database.create_table(TEST_TEMP_TABLE)
        self.assertEqual(TEST_TEMP_TABLE, temp.name)

    def test_create_table_with_bigserial(self):
        temp = self.database.create_table(TEST_TEMP_TABLE, row_identifier_type='BIGSERIAL')
        self.assertEqual(TEST_TEMP_TABLE, temp.name)

    def test_create_table_with_relational_fields(self):
        temp = self.database.create_table(TEST_TEMP_TABLE, **RELATIONAL_FIELDS)
        self.assertEqual(TEST_TEMP_TABLE, temp.name)

    def test_drop_table(self):
        self.database.drop_table(TEST_TABLE)
        self.assertEqual(False, self.database.table_exists(TEST_TABLE))

    def test_get_or_create_table_with_existing(self):
        temp = self.database.get_or_create_table(TEST_TABLE)
        self.assertEqual(TEST_TABLE, temp.name)

    def test_get_or_create_table_without_existing(self):
        temp = self.database.get_or_create_table(TEST_TEMP_TABLE)
        self.assertEqual(TEST_TEMP_TABLE, temp.name)
コード例 #4
0
class PostgresNoSQLClientTest(unittest.TestCase):

    def setUp(self):
        self.client = PostgresNoSQLClient(host=TEST_DB_HOST, user=TEST_DB_USER, password=TEST_DB_PASSWORD)

        # pre init cleanup
        if self.client.database_exists(TEST_DATABASE):
            self.client.drop_database(TEST_DATABASE)
            print('DB TRUE (%s)' % TEST_DATABASE)
        else:
            print('DB FALSE (%s)' % TEST_DATABASE)

        if self.client.database_exists(TEST_TEMP_DATABASE):
            self.client.drop_database(TEST_TEMP_DATABASE)

        self.database = self.client.create_database(TEST_DATABASE)
        self.temp_db = None

    def tearDown(self):
        # cleanup
        if self.temp_db is not None:
            self.temp_db.close()

        if self.database is not None:
            self.database.close()

        if self.client.database_exists(TEST_TEMP_DATABASE):
            self.client.drop_database(TEST_TEMP_DATABASE)

        if self.client.database_exists(self.database.name):
            self.client.drop_database(self.database.name)

        self.database = None
        self.temp_db = None
        self.client = None

    def test_init_without_parameter(self):
        client = PostgresNoSQLClient()
        self.assertEqual(DEFAULT_POSTGRES_HOST, client.host)
        self.assertEqual(DEFAULT_POSTGRES_PORT, client.port)
        self.assertEqual(DEFAULT_POSTGRES_DATABASE, client.database)

    def test_init_with_parameter(self):
        client = PostgresNoSQLClient(host='test', port=2000, database='my_test', user='******', password='******')
        self.assertEqual('test', client.host)
        self.assertEqual(2000, client.port)
        self.assertEqual('my_test', client.database)

    def test_create_database(self):
        self.temp_db = self.client.create_database(TEST_TEMP_DATABASE)
        self.assertEqual(TEST_TEMP_DATABASE, self.temp_db.name)
        self.assertNotEqual(None, self.temp_db.connection, 'no connection established')

    def test_database_exists(self):
        self.assertEqual(True, self.client.database_exists(TEST_DATABASE))
        self.assertEqual(False, self.client.database_exists(TEST_DATABASE+'12345'))

    def test_drop_database(self):
        self.temp_db = self.client.create_database(TEST_TEMP_DATABASE)
        self.temp_db.close()
        self.client.drop_database(TEST_TEMP_DATABASE)
        self.assertEqual(False, self.client.database_exists(TEST_TEMP_DATABASE))

    def test_get_database_with_existing(self):
        self.temp_db = self.client.get_database(TEST_DATABASE)
        self.assertEqual(TEST_DATABASE, self.temp_db.name)
        self.assertNotEqual(None, self.temp_db.connection, 'no connection established')

    def test_get_database_without_existing(self):
        self.temp_db = self.client.get_database(TEST_DATABASE+'12345')
        self.assertEqual(None, self.temp_db, 'there should be no database')

    def test_get_or_create_with_existing(self):
        self.temp_db = self.client.get_or_create_database(TEST_DATABASE)
        self.assertEqual(TEST_DATABASE, self.temp_db.name)

    def test_get_or_create_without_existing(self):
        self.temp_db = self.client.get_or_create_database(TEST_TEMP_DATABASE)
        self.assertEqual(TEST_TEMP_DATABASE, self.temp_db.name)
コード例 #5
0
class PostgresNoSQLTableTest(unittest.TestCase):
    def setUp(self):
        self.client = PostgresNoSQLClient(host=TEST_DB_HOST, user=TEST_DB_USER, password=TEST_DB_PASSWORD)

        # pre cleanup
        if self.client.database_exists(TEST_DATABASE):
            self.client.drop_database(TEST_DATABASE)

        self.database = self.client.create_database(TEST_DATABASE)
        self.table = self.database.create_table(TEST_TABLE)
        self.relational_table = self.database.create_table(TEST_RELATIONAL_TABLE, **RELATIONAL_FIELDS)

        # fill table
        self.first = self.table.put(JSON_DATA)
        self.first_relational = self.relational_table.put(JSON_DATA, **RELATIONAL_DATA)

    def tearDown(self):
        # cleanup
        if self.database is not None:
            self.database.close()

        if self.client.database_exists(self.database.name):
            self.client.drop_database(self.database.name)

    def test_get_empty_record(self):
        record = self.table.get(self.first+1)
        self.assertEqual(None, record)

    def test_get_json_field(self):
        record = self.table.get(self.first)
        self.assertEqual('blue', record.json['color'])

    def test_get_relational_field(self):
        record = self.relational_table.get(self.first_relational)
        self.assertEqual(24, record['age'])

    def test_insert(self):
        id = self.relational_table.insert(name="pascal", age=22, height=182)
        record = self.relational_table.get(id)
        self.assertEqual(22, record['age'])

    def test_put_json(self):
        id = self.table.put(JSON_DATA)
        record = self.table.get(id)
        self.assertEqual(3, record.json['items'])

    def test_put_json_with_none(self):
        id = self.table.put(None)
        record = self.table.get(id)
        self.assertEqual(None, record.get_record()[DEFAULT_JSON_COLUMN_NAME])

    def test_put_relational(self):
        id = self.relational_table.put(JSON_DATA, **RELATIONAL_DATA)
        record = self.relational_table.get(id)
        self.assertEqual(179.5, record['height'])

    def test_put_relational_without_auto_commit(self):
        id = self.relational_table.put(JSON_DATA, auto_commit=False, **RELATIONAL_DATA)
        self.relational_table.connection.rollback()
        record = self.relational_table.get(id)
        self.assertEqual(None, record)

    def test_put_relational_with_none(self):
        id = self.relational_table.put(JSON_DATA, name='florian', age=24, height=None)
        record = self.relational_table.get(id)
        self.assertEqual(None, record['height'])

    def test_update(self):
        record = self.relational_table.get(self.first_relational)
        self.relational_table.update(record.id, age=5)
        record = self.relational_table.get(self.first_relational)
        self.assertEqual(5, record['age'])

    def test_save_on_item(self):
        record = self.relational_table.get(self.first_relational)
        record['age'] = 5
        record.save()
        record = self.relational_table.get(self.first_relational)
        self.assertEqual(5, record['age'])

    def test_save_json(self):
        record = self.table.get(self.first)
        record.json['items'] = 15
        self.table.save(record)
        record = self.table.get(self.first)
        self.assertEqual(15, record.json['items'])

    def test_save_object_further_use(self):
        record = self.relational_table.get(self.first_relational)
        record.json['items'] = 15
        self.relational_table.save(record)
        self.assertEqual(15, record.json['items'])
        self.assertEqual('florian', record['name'])

    def test_save_json_with_none(self):
        record = self.table.get(self.first)
        record.json['items'] = None
        self.table.save(record)
        record = self.table.get(self.first)
        self.assertEqual(None, record.json['items'])

    def test_save_relational(self):
        record = self.relational_table.get(self.first_relational)
        record['age'] = 25
        self.relational_table.save(record)
        record = self.relational_table.get(self.first_relational)
        self.assertEqual(25, record['age'])

    def test_save_auto_commit(self):
        record = self.relational_table.get(self.first_relational)
        record['age'] = 25
        self.relational_table.save(record)
        self.relational_table.connection.rollback()
        record = self.relational_table.get(self.first_relational)
        self.assertEqual(25, record['age'])

    def test_save_without_auto_commit(self):
        record = self.relational_table.get(self.first_relational)
        record['age'] = 25
        self.relational_table.save(record, auto_commit=False)
        self.relational_table.connection.rollback()
        record = self.relational_table.get(self.first_relational)
        self.assertEqual(24, record['age'])

    def test_save_relational_with_none(self):
        record = self.relational_table.get(self.first_relational)
        record['height'] = None
        self.relational_table.save(record)
        record = self.relational_table.get(self.first_relational)
        self.assertEqual(None, record['height'])

    def test_query(self):
        records = self.relational_table.query()
        self.assertNotEqual(None, records)

    def test_delete_record(self):
        self.table.delete(self.first)
        record = self.table.get(self.first)
        self.assertEqual(None, record)