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 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_insert_encoded(self):
        DatabaseInsertRows.insert(self.database_name,
                                  self.table_name,
                                  self.columns,
                                  self.row,
                                  encoding="base64")
        database = Database(self.database_name, True)
        with database:
            _, result, _ = tbl_rows_get(database, self.table_name)

        self.assertEqual(DatabaseBase._decode_2darray(result), self.row)
 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 setUp(self):
        self.database_name = 'foobar'
        self.table_name = 'foobar'
        columns = ['col1', 'col2', 'col3']
        column_defn = [('col1', 'text'), ('col2', 'text'), ('col3', 'integer')]
        self.row = [['x', 'y', 6]]
        self.qrow = _quotestrs(self.row)
        self.filename = "b64pyshell.txt"
        self.b64row = _quotestrs(DatabaseBase._encode_2darray(self.row))
        database = Database('foobar')

        with database:
            tbl_create(database, self.database_name, column_defn)
            tbl_rows_insert(database, self.table_name, columns, self.b64row)
    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)