def test_(self):
        append_text_to_file(
            self.filename, "columns:" +
            "$$".join([b64encode(field) for field in self.columns]) + "\n")
        rows = get_2darray_from_file(path.join(TESTDIR, "testdata.csv"))
        put_2darray_in_file(self.filename,
                            rows,
                            suffix="rows:",
                            encoding="base64")

        DatabaseInsertRows.insert_by_file(self.filename)

        database = Database(self.database_name, True)
        with database:
            columns, rows, _ = tbl_query(
                database,
                "select Description from foobar where LastName = \"" +
                b64encode("Osborn") + "\"")

        expected_results = [
            b64encode(
                "dictum mi, ac mattis velit justo nec ante. Maecenas mi felis, adipiscing fringilla, porttitor vulputate, posuere vulputate, lacus. Cras interdum. Nunc sollicitudin commodo ipsum. Suspendisse non leo. Vivamus nibh dolor, nonummy ac, feugiat non, lobortis quis, pede. Suspendisse dui. Fusce diam nunc, ullamcorper eu, euismod ac, fermentum vel, mauris. Integer sem elit, pharetra ut, pharetra sed, hendrerit a, arcu. Sed et"
            )
        ]
        self.assertListEqual(rows[0], expected_results)
    def test_insert_encoded_by_file(self):
        append_text_to_file(
            self.filename,
            "database_name:" + b64encode(self.database_name) + "\n")
        append_text_to_file(self.filename,
                            "table_name:" + b64encode(self.table_name) + "\n")
        append_text_to_file(self.filename,
                            "delete_flag:" + b64encode("False") + "\n")
        append_text_to_file(self.filename,
                            "decode_flag:" + b64encode("True") + "\n")
        append_text_to_file(
            self.filename, "columns:" +
            "$$".join([b64encode(field) for field in self.columns]) + "\n")

        put_2darray_in_file(self.filename,
                            self.row,
                            suffix="rows:",
                            encoding="base64")
        DatabaseInsertRows.insert_by_file(self.filename,
                                          runtime_path=self.runtime_path)
        database = Database(
            self.runtime_path + "\\" + self.database_name + ".sqlite", True)

        with database:
            _, result, _ = tbl_rows_get(database, self.table_name)

        self.assertEqual(DatabaseBase._decode_2darray(result), self.row)
    def setUp(self):
        self.database_name = 'foobar'
        self.table_name = 'foobar'
        self.column_defn = [('FirstName', 'text'), ('LastName', 'text'),
                            ('Country', 'text'), ('Description', 'text'),
                            ('Age', 'integer')]
        self.columns = [
            'FirstName', 'LastName', 'Country', 'Description', 'Age'
        ]

        self.filename = "b64pyshell.txt"

        append_text_to_file(
            self.filename,
            "database_name:" + b64encode(self.database_name) + "\n")
        append_text_to_file(self.filename,
                            "table_name:" + b64encode(self.table_name) + "\n")
        append_text_to_file(self.filename,
                            "delete_flag:" + b64encode("False") + "\n")
        append_text_to_file(
            self.filename, "column_defns:" + "$$".join([
                b64encode(_name) + "^" + b64encode(_type)
                for _name, _type in self.column_defn
            ]) + "\n")

        DatabaseCreateTable.create_by_file(self.filename)
    def test_create_by_file_encoded_an_set_runtime_path(self):
        self.filename = "b64pyshell.txt"
        runtime_path = "C:\\Users\\burtnolej"
        append_text_to_file(
            self.filename,
            "database_name:" + b64encode(self.database_name) + "\n")
        append_text_to_file(self.filename,
                            "table_name:" + b64encode(self.table_name) + "\n")
        append_text_to_file(self.filename,
                            "delete_flag:" + b64encode("False") + "\n")

        append_text_to_file(
            self.filename, "column_defns:" + "$$".join([
                b64encode(_name) + "^" + b64encode(_type)
                for _name, _type in self.column_defn
            ]) + "\n")
        DatabaseCreateTable.create_by_file(self.filename,
                                           runtime_path=runtime_path)

        database = Database(
            runtime_path + "\\" + self.database_name + ".sqlite", True)

        with database:
            self.assertTrue(tbl_exists(database, self.table_name))

        os_file_delete(self.filename)
    def test_insert_by_file_encoded(self):
        # encoding of input / output files
        # encoding of database content

        append_text_to_file(
            self.filename,
            "database_name:" + b64encode(self.database_name) + "\n")
        append_text_to_file(self.filename,
                            "table_name:" + b64encode(self.table_name) + "\n")
        append_text_to_file(self.filename,
                            "delete_flag:" + b64encode("False") + "\n")
        #append_text_to_file(self.filename,"decode_flag:"+b64encode("False") + "\n")
        append_text_to_file(
            self.filename, "columns:" +
            "$$".join([b64encode(field) for field in self.columns]) + "\n")

        put_2darray_in_file(self.filename,
                            self.row,
                            suffix="rows:",
                            encoding="base64")

        DatabaseInsertRows.insert_by_file(self.filename)

        database = Database(self.database_name, True)
        with database:
            _, result, _ = tbl_rows_get(database, self.table_name)

        self.assertEqual(DatabaseBase._decode_2darray(result), self.row)
        os_file_delete(self.filename)
    def test_get_table_list(self):
        os_file_delete(self.filename)
        append_text_to_file(
            self.filename,
            "database_name:" + b64encode(self.database_name) + "\n")
        append_text_to_file(self.filename,
                            "delete_flag:" + b64encode("True") + "\n")

        self.assertEquals(DatabaseMisc.get_table_list_by_file(self.filename),
                          [u'foobar'])
    def test_fail_database(self):
        os_file_delete(self.filename)
        append_text_to_file(self.filename,
                            "database_name:" + b64encode("foofoo") + "\n")
        append_text_to_file(self.filename,
                            "table_name:" + b64encode(self.table_name) + "\n")
        append_text_to_file(self.filename,
                            "delete_flag:" + b64encode("True") + "\n")

        self.assertFalse(DatabaseMisc.database_exists_by_file(self.filename))
        os_file_delete(self.database_name + ".sqlite")
    def test_(self):
        os_file_delete(self.filename)
        append_text_to_file(
            self.filename,
            "database_name:" + b64encode(self.database_name) + "\n")
        append_text_to_file(self.filename,
                            "table_name:" + b64encode(self.table_name) + "\n")
        append_text_to_file(self.filename,
                            "delete_flag:" + b64encode("True") + "\n")

        self.assertTrue(DatabaseMisc.table_exists_by_file(self.filename))
 def test_query_by_file_encoded(self):
     append_text_to_file(
         self.filename,
         "database_name:" + b64encode(self.database_name) + "\n")
     append_text_to_file(
         self.filename, "qry_str:" +
         b64encode("select col1,col2,col3 from " + self.table_name) + "\n")
     append_text_to_file(self.filename,
                         "delete_flag:" + b64encode("True") + "\n")
     result = DatabaseQueryTable.query_by_file(self.filename)
     self.assertEquals(self.row, DatabaseBase._decode_2darray(result))
     os_file_delete(self.filename)
    def test_get_columns(self):
        os_file_delete(self.filename)
        append_text_to_file(
            self.filename,
            "database_name:" + b64encode(self.database_name) + "\n")
        append_text_to_file(self.filename,
                            "table_name:" + b64encode(self.table_name) + "\n")
        append_text_to_file(self.filename,
                            "delete_flag:" + b64encode("True") + "\n")

        self.assertEquals(DatabaseMisc.get_table_info_by_file(self.filename),
                          [(u'FirstName', u'text'), (u'LastName', u'text'),
                           (u'Country', u'text'), (u'Description', u'text'),
                           (u'Age', u'integer')])
    def test_query_encoded_by_file(self):
        append_text_to_file(
            self.filename,
            "database_name:" + b64encode(self.database_name) + "\n")
        append_text_to_file(
            self.filename, "qry_str:" +
            b64encode("select col1,col2,col3 from " + self.table_name) + "\n")
        append_text_to_file(self.filename,
                            "delete_flag:" + b64encode("True") + "\n")
        result = DatabaseQueryTable.query_by_file(
            self.filename, result_file=self.result_filename)

        self.assertEqual(
            "eA==^eQ==^Ng==",
            os_file_to_string(self.result_filename).split("\n")[0])
    def test_create_by_file_encoded(self):
        self.filename = "b64pyshell.txt"
        append_text_to_file(
            self.filename,
            "database_name:" + b64encode(self.database_name) + "\n")
        append_text_to_file(self.filename,
                            "table_name:" + b64encode(self.table_name) + "\n")
        append_text_to_file(self.filename,
                            "delete_flag:" + b64encode("False") + "\n")
        append_text_to_file(
            self.filename, "column_defns:" + "$$".join([
                b64encode(_name) + "^" + b64encode(_type)
                for _name, _type in self.column_defn
            ]) + "\n")
        DatabaseCreateTable.create_by_file(self.filename)

        database = Database(self.database_name, True)
        with database:
            self.assertTrue(tbl_exists(database, self.table_name))

        os_file_delete(self.filename)
    def test_(self):

        rows = get_2darray_from_file(path.join(TESTDIR, "testdata_2rows.csv"))

        append_text_to_file(
            self.filename,
            "database_name:" + b64encode(self.database_name) + "\n")
        append_text_to_file(self.filename,
                            "table_name:" + b64encode(self.table_name) + "\n")
        append_text_to_file(self.filename,
                            "delete_flag:" + b64encode("False") + "\n")
        append_text_to_file(self.filename,
                            "decode_flag:" + b64encode("False") + "\n")
        append_text_to_file(
            self.filename, "columns:" +
            "$$".join([b64encode(field) for field in self.columns]) + "\n")
        append_text_to_file(
            self.filename, "column_defns:" + "$$".join([
                b64encode(_name) + "^" + b64encode(_type)
                for _name, _type in self.column_defn
            ]) + "\n")

        put_2darray_in_file(self.filename,
                            rows,
                            suffix="rows:",
                            encoding="base64")

        clsobj = DatabaseBase._parse_input_file(self.filename,
                                                mandatory_fields=[
                                                    'database_name',
                                                    'table_name',
                                                    'delete_flag',
                                                    'decode_flag', 'columns',
                                                    'column_defns'
                                                ],
                                                encoding="base64")

        self.assertEqual(clsobj.database_name, self.database_name)
        self.assertEqual(clsobj.table_name, self.table_name)
        self.assertEqual(clsobj.delete_flag, False)
        self.assertEqual(clsobj.decode_flag, False)
        self.assertEqual(clsobj.runtime_path, ".")
        self.assertEqual(clsobj.columns, self.columns)
        self.assertEqual(clsobj.column_defns, self.column_defn)
        self.assertEqual(len(clsobj.rows), 2)
        self.assertEqual(len(clsobj.rows[0]), 5)
    def setUp(self):
        self.database_name = 'foobar'
        self.table_name = 'foobar'
        self.columns = ['col1', 'col2', 'col3']
        self.column_defn = [('col1', 'text'), ('col2', 'text'),
                            ('col3', 'integer')]
        self.row = [['x', 'y', 6]]
        self.qrow = _quotestrs(self.row)
        self.filename = "b64pyshell.txt"
        self.b64row = DatabaseBase._encode_2darray(self.row)

        self.runtime_path = "C:\\Users\\burtnolej"
        append_text_to_file(
            self.filename,
            "database_name:" + b64encode(self.database_name) + "\n")
        append_text_to_file(self.filename,
                            "table_name:" + b64encode(self.table_name) + "\n")
        append_text_to_file(self.filename,
                            "delete_flag:" + b64encode("False") + "\n")
        append_text_to_file(
            self.filename, "columns:" +
            "$$".join([b64encode(field) for field in self.columns]) + "\n")
        append_text_to_file(
            self.filename, "column_defns:" + "$$".join([
                b64encode(_name) + "^" + b64encode(_type)
                for _name, _type in self.column_defn
            ]) + "\n")
        append_text_to_file(
            self.filename, "qry_str:" +
            b64encode("select col1,col2,col3 from " + self.table_name) + "\n")

        put_2darray_in_file(self.filename, self.b64row, suffix="rows:")
        DatabaseCreateTable.create_by_file(self.filename,
                                           runtime_path=self.runtime_path)
        DatabaseInsertRows.insert_by_file(self.filename,
                                          runtime_path=self.runtime_path)
 def test_query_encoded(self):
     qry_str = b64encode("select col1,col2,col3 from " + self.table_name)
     result = DatabaseQueryTable.query_encoded(self.database_name,
                                               qry_str,
                                               delete_flag=True)
     self.assertEquals(self.row, DatabaseBase._decode_2darray(result))
 def test_(self):
     append_text_to_file(self.filename,
                         "delete_flag:" + b64encode("True") + "\n")
     result = DatabaseQueryTable.query_by_file(
         self.filename, runtime_path=self.runtime_path)
     self.assertEqual(DatabaseBase._decode_2darray(result), self.row)