Python util.rand_string函数代码示例

    def test_given_request_xml(self):
        value = util.rand_string()

        _base_dir = util.rand_string()
        _format = 'XML'
        _request_path = util.rand_string()

        def get_full_path(base_dir, format, req_or_resp, request_path):
            self.assertEquals(base_dir, _base_dir)
            self.assertEquals(format, _format.lower())
            self.assertEquals(req_or_resp, 'request')
            self.assertEquals(request_path, _request_path)

        def get_file(*ignored_args, **ignored_kwargs):
            return '<abc>{}</abc>'.format(value)

        with patch('zato.apitest.util.get_full_path', get_full_path):
            with patch('zato.apitest.util.get_file', get_file):
                self.ctx.zato.request.format = _format
                self.ctx.zato.request.is_xml = True
                self.ctx.zato.environment_dir = _base_dir

                common.given_request(self.ctx, _request_path)

                self.assertEquals(self.ctx.zato.request.is_xml, True)
                self.assertEquals(self.ctx.zato.request.get('is_json', INVALID), INVALID)
                self.assertEquals(self.ctx.zato.request.data_impl.xpath('/abc')[0].text, value)

    def setUp(self):
        self.ctx = Bunch()
        self.ctx.zato = util.new_context(None, util.rand_string(), {})

        # setup initial Cassandra keyspace
        self.current_session_name = util.rand_string()
        self.columns = ['userid', 'fname', 'sname']
        self.values = util.rand_string(3)
        self.keyspace = util.rand_string()
        self.table = util.rand_string()
        data = (self.keyspace, self.table) + tuple(s for s in self.columns)
        keyspace_statement = (
            "CREATE KEYSPACE %s WITH REPLICATION = { 'class' : 'SimpleStrategy', 'replication_factor' : 3 }") % self.keyspace
        table_statement = ("CREATE TABLE %s.%s (%s text PRIMARY KEY, %s text, %s text)") % data

        self.embedded_cassandra = pysandraunit.PysandraUnit(native_transport_port=9042)
        self.embedded_cassandra.start()
        self.cluster = Cluster(protocol_version=1)
        self.session = self.cluster.connect()
        self.session.execute(keyspace_statement)
        self.session.execute(table_statement)
        self.cluster.shutdown()

        # setup Cassandra ctx
        cassandra_.given_cassandra_contact_points(self.ctx, 'localhost')
        cassandra_.given_cassandra_protocol_version(self.ctx, 1)
        cassandra_.given_cassandra_port(self.ctx, '9042')
        cassandra_.given_i_connect_to_keyspace_as_session(self.ctx, self.keyspace, self.current_session_name)

    def test_given_request_json(self):
        value = util.rand_string()

        _base_dir = util.rand_string()
        _format = 'JSON'
        _request_path = util.rand_string()

        def get_full_path(base_dir, format, req_or_resp, request_path):
            self.assertEquals(base_dir, _base_dir)
            self.assertEquals(format, _format.lower())
            self.assertEquals(req_or_resp, 'request')
            self.assertEquals(request_path, _request_path)

        def get_file(*ignored_args, **ignored_kwargs):
            return '{"abc":"%s"}' % value

        with patch('zato.apitest.util.get_full_path', get_full_path):
            with patch('zato.apitest.util.get_file', get_file):
                self.ctx.zato.request.format = _format
                self.ctx.zato.request.is_json = True
                self.ctx.zato.environment_dir = _base_dir

                common.given_request(self.ctx, _request_path)

                self.assertEquals(self.ctx.zato.request.get('is_xml', INVALID), INVALID)
                self.assertEquals(self.ctx.zato.request.is_json, True)
                self.assertEquals(self.ctx.zato.request.data_impl['abc'], value)

    def setUp(self):
        # TODO: Cassandra tests are failing due to """PysandraUnitServerError:
        # Failed to execute command start: /127.0.0.1:7010 is in use by another process.
        # Change listen_address:storage_port in cassandra.yaml to values that do not conflict with other services"""
        return
        self.ctx = Bunch()
        self.ctx.zato = util.new_context(None, util.rand_string(), {})

        import time
        time.sleep(2)

        # setup initial Cassandra keyspace
        self.current_session_name = util.rand_string()
        self.columns = ['userid', 'fname', 'sname']
        self.values = util.rand_string(3)
        self.keyspace = util.rand_string()
        self.table = util.rand_string()
        data = (self.keyspace, self.table) + tuple(s for s in self.columns)
        keyspace_statement = (
            "CREATE KEYSPACE %s WITH REPLICATION = { 'class' : 'SimpleStrategy', 'replication_factor' : 3 }") % self.keyspace
        table_statement = ("CREATE TABLE %s.%s (%s text PRIMARY KEY, %s text, %s text)") % data

        self.embedded_cassandra = pysandraunit.PysandraUnit(native_transport_port=9042)
        self.embedded_cassandra.start()
        self.cluster = Cluster(protocol_version=1)
        self.session = self.cluster.connect()
        self.session.execute(keyspace_statement)
        self.session.execute(table_statement)
        self.cluster.shutdown()

        # setup Cassandra ctx
        cassandra_.given_cassandra_contact_points(self.ctx, 'localhost')
        cassandra_.given_cassandra_protocol_version(self.ctx, 1)
        cassandra_.given_cassandra_port(self.ctx, '9042')
        cassandra_.given_i_connect_to_keyspace_as_session(self.ctx, self.keyspace, self.current_session_name)

 def test_given_i_store_sql_query_result_under_name_multi_elem_list(self):
     id = util.rand_int()
     name = util.rand_string()
     value = util.rand_string()
     self.cursor.execute("INSERT INTO TestDB (id, name, value) VALUES (?,?,?)", (id, name, value))
     self.conn.commit()
     q = 'SELECT name FROM TestDb'
     sql.given_i_store_sql_query_result_under_name(self.ctx, q, 'sql_result_multi', self.general_conn)
     self.assertEquals(self.ctx.zato.user_ctx['sql_result_multi'], [(self.name,), (name,)])

    def test_i_insert_data_from_csv_file_to_cassandra_table(self, open_mock):
        values = (util.rand_string(), util.rand_string(), util.rand_string())
        fake_csv = 'userid, fname, sname\n%s, %s, %s' % values
        filename = util.rand_string()

        open_mock.return_value = StringIO(fake_csv)
        cassandra_.i_insert_data_from_csv_file_to_cassandra_table(self.ctx, filename, self.table, self.current_session_name)

        statement = "SELECT * FROM %s" % self.table
        cassandra_.given_i_store_cql_query_result_under_name(self.ctx, statement, 'cql_result', self.current_session_name, 0)
        self.assertEquals(self.ctx.zato.user_ctx['cql_result'], ';'.join(values))

    def test_given_i_store_zato_info_under_conn_name(self):
        conn_name = util.rand_string()
        cluster_id = util.rand_int()
        url_path = util.rand_string()
        username = util.rand_string()
        password = util.rand_string()
        zato_.given_i_store_zato_info_under_conn_name(self.ctx, cluster_id, url_path, username, password, conn_name)
        stored = self.ctx.zato.user_ctx[conn_name]

        for key in stored:
            self.assertEquals(stored[key], eval(key))

    def test_i_create_table_and_insert_data_from_csv_file_using_types_and_header(self, open_mock):
        values = (util.rand_string(), util.rand_int(), util.rand_string())
        fake_csv = 'a-text, b:integer, c/varchar:30\n%s, %s, %s' % values
        kwargs = {'filename': util.rand_string(),
                    'tablename': util.rand_string(),
                    'conn_name': self.conn}

        open_mock.return_value = StringIO(fake_csv)
        sql.insert_csv(use_header=1, use_types=1, **kwargs)

        q = self.conn.execute('SELECT * FROM {tn}'.format(tn = kwargs['tablename']))
        result = q.fetchone()
        self.assertEquals(result, values)

    def test_i_create_table_and_insert_data_from_csv_file(self, open_mock):
        values = (util.rand_string(), util.rand_string(), util.rand_string())
        fake_csv = '%s, %s, %s' % values
        kwargs = {'filename': util.rand_string(),
                    'tablename': util.rand_string(),
                    'conn_name': self.conn}

        open_mock.return_value = StringIO(fake_csv)
        sql.insert_csv(use_types='default', **kwargs)

        q = self.conn.execute('SELECT * FROM {tn}'.format(tn = kwargs['tablename']))
        result = q.fetchone()
        self.assertEquals(result, values)

    def test_i_insert_data_from_csv_file(self, open_mock):
        values = (util.rand_int(), util.rand_string(), util.rand_string())
        fake_csv = 'id, name, value\n%s, %s, %s' % values
        kwargs = {'filename': util.rand_string(),
                    'tablename': 'TestDB',
                    'conn_name': self.general_conn}

        open_mock.return_value = StringIO(fake_csv)
        sql.insert_csv(use_header=1, **kwargs)

        q = self.general_conn.execute('SELECT * FROM TestDB')
        result = q.fetchall()[1]
        self.assertEquals(result, values)

    def test_i_create_table_and_insert_data_from_csv_file_using_header(self, open_mock):
        colnames = (tuple((element) for element in util.rand_string(5)))
        values = (util.rand_string(), util.rand_string(), util.rand_int(), round(util.rand_float(), 4), util.rand_string())
        t = colnames + values
        fake_csv = '%s, %s, %s, %s, %s\ntext, varchar:30, integer, float, char\n%s, %s, %s, %s, %s' % t
        kwargs = {'filename': util.rand_string(),
                    'tablename': util.rand_string(),
                    'conn_name': self.conn}

        open_mock.return_value = StringIO(fake_csv)
        sql.insert_csv(use_header=1, use_types=0, **kwargs)

        q = self.conn.execute('SELECT * FROM {tn}'.format(tn = kwargs['tablename']))
        result = q.fetchone()
        self.assertEquals(result, values)

    def test_i_insert_data_from_csv_file_to_cassandra_table(self, open_mock):
        # TODO: Cassandra tests are failing due to """PysandraUnitServerError:
        # Failed to execute command start: /127.0.0.1:7010 is in use by another process.
        # Change listen_address:storage_port in cassandra.yaml to values that do not conflict with other services"""
        return
        values = (util.rand_string(), util.rand_string(), util.rand_string())
        fake_csv = 'userid, fname, sname\n%s, %s, %s' % values
        filename = util.rand_string()

        open_mock.return_value = StringIO(fake_csv)
        cassandra_.i_insert_data_from_csv_file_to_cassandra_table(self.ctx, filename, self.table, self.current_session_name)

        statement = "SELECT * FROM %s" % self.table
        cassandra_.given_i_store_cql_query_result_under_name(self.ctx, statement, 'cql_result', self.current_session_name, 0)
        self.assertEquals(self.ctx.zato.user_ctx['cql_result'], ';'.join(values))

    def test_given_request_xml_no_data(self):

        class _RequestPath(object):
            def __init__(self):
                self.value = util.rand_string()

            def __nonzero__(self):
                return False

        _base_dir = util.rand_string()
        _format = 'XML'
        _request_path = _RequestPath()

        def get_full_path(base_dir, format, req_or_resp, request_path):
            self.assertEquals(base_dir, _base_dir)
            self.assertEquals(format, _format.lower())
            self.assertEquals(req_or_resp, 'request')
            self.assertEquals(request_path.value, _request_path.value)

        def get_file(*ignored_args, **ignored_kwargs):
            pass

        with patch('zato.apitest.util.get_full_path', get_full_path):
            with patch('zato.apitest.util.get_file', get_file):
                self.ctx.zato.request.format = 'XML'
                self.ctx.zato.environment_dir = _base_dir

                self.assertRaises(ValueError, common.given_request, self.ctx, _request_path)

    def test_new_context_from_environment_dir(self):

        # Same comment as in test_new_context_from_old_ctx.
        for x in range(2):
            environment_dir = rand_string()
            ctx = new_context(None, environment_dir, {})
            self._test_new_context(ctx, environment_dir)

 def test_given_json_pointer_is_rand_date_between(self):
     path = util.rand_string()
     date_start = (datetime.now().strftime('%Y-%m-%d'))
     date_end = (datetime.now() + relativedelta(months=6)).strftime('%Y-%m-%d')
     json.given_json_pointer_is_rand_date_between(self.ctx, '/' + path, date_start, date_end, 'default')
     rand_date_between = datetime.strptime(self.ctx.zato.request.data_impl[path], '%Y-%m-%dT%H:%M:%S')
     self.assertLess(datetime.strptime(date_start, '%Y-%m-%d'), rand_date_between)
     self.assertGreater(datetime.strptime(date_end, '%Y-%m-%d'), rand_date_between)