Wei Wang - RankMe

Year	Rank	Type	Title / Venue / Authors
2023	A	`conf`	A Rotor Flywheel Robot: Land-air Amphibious Design and Control. IROS Chunzheng Wang, Yunyi Zhang, Chuanzhao Li, Wei Wang, Yangmin Li
2021	A*	`conf`	Reduced Dynamics and Control for an Autonomous Bicycle. ICRA Jiaming Xiong, Bo Li, Ruihan Yu, Daolin Ma, Wei Wang, Caishan Liu
2021	J	`jnl`	Reduced Dynamics and Control for an Autonomous Bicycle. CoRR Jiaming Xiong, Bo Li, Ruihan Yu, Daolin Ma, Wei Wang, Caishan Liu
2018	J	`jnl`	Design and Dynamic Modeling of Variable Stiffness Joint Actuator Based on Archimedes Spiral. IEEE Access Wei Wang, Yanwei Zhao, Yangmin Li
2018	J	`jnl`	Design and Implementation of a Two-Wheel and Hopping Robot With a Linkage Mechanism. IEEE Access Yanheng Zhang, Lufeng Zhang, Wei Wang, Yangmin Li, Qingwen Zhang
2018	J	`jnl`	Design and implementation of a variable stiffness actuator based on flexible gear rack mechanism. Robotica Wei Wang, Xiaoyue Fu, Yangmin Li, Chao Yun
2016	J	`jnl`	A caterpillar climbing robot with spine claws and compliant structural modules. Robotica Wei Wang, Shilin Wu
2016	—	`conf`	A research on air posture adjustment of flying squirrel inspired gliding robot. ROBIO Xuepeng Li, Wei Wang, Shilin Wu, Peihua Zhu, Linqing Wang
2016	—	`conf`	Configuration and trajectory optimization for a Gecko Inspired climbing robot with a Pendular waist. ROBIO Peihua Zhu, Wei Wang, Shilin Wu, Xuepeng Li, Fanguang Meng
2016	—	`conf`	Enhancement of Virtual Simulator for Marine Crane Operations via Haptic Device with Force Feedback. EuroHaptics (1) Yingguang Chu, Houxiang Zhang, Wei Wang
2015	A	`conf`	Analysis on the dynamic climbing forces of a gecko inspired climbing robot based on GPL model. IROS Wei Wang, Shilin Wu, Peihua Zhu, Rong Liu
2015	J	`jnl`	Design and experimental study of a new thrown robot based on flexible structure. Ind. Robot Wei Wang, Shilin Wu, Peihua Zhu, Xuepeng Li
2014	J	`jnl`	A calibration method of kinematic parameters for serial industrial robots. Ind. Robot Wei Wang, Gang Wang, Chao Yun
2014	—	`conf`	Analysis on GPL's dynamic gait for a gecko inspired climbing robot with a passive waist joint. ROBIO Shilin Wu, Wei Wang, Di Wu, Chen Chen, Peihua Zhu, Rong Liu
2012	J	`jnl`	Analysis of Gait and Mechanical Property of Wall-climbing Caterpillar Robot. J. Comput. Kun Wang, Wei Wang, Houxiang Zhang
2010	A	`conf`	Efficient kinematic solution to a multi-robot with serial and parallel mechanisms. IROS Houxiang Zhang, Gionata Salvietti, Wei Wang, Guoyuan Li, Junzhi Yu, Jianwei Zhang
2010	A*	`conf`	Internal force compensating method for wall-climbing caterpillar robot. ICRA Wei Wang, Kun Wang, Houxiang Zhang, Jianwei Zhang
2010	J	`jnl`	Robotic cleaning system for glass facade of high-rise airport control tower. Ind. Robot Wei Wang, Boyan Tang, Houxiang Zhang, Guanghua Zong
2009	—	`conf`	An autonomous docking method based on ultrasonic sensors for self-reconfigurable mobile robot. ROBIO Wei Wang, Zongliang Li, Wenpeng Yu, Jianwei Zhang
2009	—	`conf`	Analysis of gait control of wall-climbing caterpillar robot. ROBIO Dazhai Li, Xianyue Ma, Kun Wang, Wei Wang, Houxiang Zhang, Guanghua Zong
2009	A	`conf`	Crawling Locomotion of Modular Climbing Caterpillar Robot with Changing Kinematic Chain. IROS Wei Wang, Houxiang Zhang, Jianwei Zhang
2009	J	`jnl`	Design and Realization of a Novel Modular Climbing Caterpillar Using Low-Frequency Vibrating Passive Suckers. Adv. Robotics Houxiang Zhang, Wei Wang, Juan González-Gómez, Jianwei Zhang
2009	A	`conf`	Docking manipulator for a reconfigurable mobile robot system. IROS Wei Wang, Wenpeng Yu, Houxiang Zhang, Jianwei Zhang
2009	—	`conf`	Research and design of rigid docking mechanism applied on field modular self-reconfigurable robot system. ROBIO Wenpeng Yu, Wei Wang, Zongliang Li, Huilin Tang, Guanghua Zong
2008	B	`conf`	A distributed coordination system for modular reconfigurable robots. WiOpt Zhicheng Deng, Wei Wang
2008	—	`conf`	Analysis of two vibrating suction methods. ROBIO Kun Wang, Wei Wang, Dazhai Li, Guanghua Zong, Houxiang Zhang, Jianwei Zhang, Zhicheng Deng
2008	—	`conf`	Applications of the Fuzzy Immune PID Control and the Genetic Algorithm in the Automated Pharmacy System. ICIRA (2) Xuefeng Zhao, Chao Yun, Yuanyuan Wang, Wei Wang
2008	J	`jnl`	Force cooperation in a reconfigurable field multirobot system. J. Field Robotics Wei Wang, Houxiang Zhang, Guanghua Zong, Jianwei Zhang
2008	—	`conf`	High stiffness pneumatic actuating scheme and improved position control strategy realization of a pneumatic climbing robot. ROBIO Houxiang Zhang, Wei Wang, Jianwei Zhang
2007	—	`conf`	A mini multi-joint wall climbing robot based on the vibrating suction method. ROBIO Na Shun Bu He, Rong Liu, Wei Wang, Hao Yang, Xu Dong Wang
2007	J	`jnl`	A series of pneumatic glass-wall cleaning robots for high-rise buildings. Ind. Robot Houxiang Zhang, Jianwei Zhang, Wei Wang, Rong Liu, Guanghua Zong
2007	—	`conf`	Drivable workspace analysis of the reconfiguration mechanism in a mobile robots system. ROBIO Wei Wang, Houxiang Zhang, Hualei Fu, Jianwei Zhang, Guanghua Zong
2007	A	`conf`	F&A compensating variable bang-bang control algorithm for pneumatic driving glass-wall cleaning robot. IROS Wei Wang, Houxiang Zhang, Wenpeng Yu, Guanghua Zong, Jianwei Zhang
2006	—	`conf`	A Method for Robustness Improvement of Robot Obstacle Avoidance Algorithm. ROBIO Guanghua Zong, Luhua Deng, Wei Wang
2006	—	`conf`	Building and Understanding Robotics?a Practical Course for Different Levels Education. ROBIO Houxiang Zhang, Tim Baier, Jianwei Zhang, Wei Wang, Rong Liu, Dazhai Li, Guanghua Zong
2006	—	`conf`	Design and Realization of a Novel Reconfigurable Robot with Serial and Parallel Mechanisms. ROBIO Wei Wang, Houxiang Zhang, Guanghua Zong, Jianwei Zhang
2006	A	`conf`	Locomotion Capabilities of a Novel Reconfigurable Robot with 3 DOF Active Joints for Rugged Terrain. IROS Houxiang Zhang, Zhicheng Deng, Wei Wang, Jianwei Zhang, Guanghua Zong
2006	J	`jnl`	Sky Cleaner 3: a real pneumatic climbing robot for glass-wall cleaning. IEEE Robotics Autom. Mag. Houxiang Zhang, Jianwei Zhang, Guanghua Zong, Wei Wang, Rong Liu
2005	—	`conf`	Design of a climbing robot for cleaning spherical surfaces. ROBIO Houxiang Zhang, Jianwei Zhang, Rong Liu, Wei Wang, Guanghua Zong

"""
Unit tests for database exporters.
"""
import pytest
import json
from dataclasses import dataclass, asdict
from datetime import datetime, timezone
from unittest.mock import Mock, patch, MagicMock

pytestmark = [pytest.mark.unit, pytest.mark.exporters]


# ============================================================================
# Sample Dataclass for Testing
# ============================================================================

@dataclass
class SampleData:
    """Sample dataclass for export testing."""
    sha256: str = "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855"
    name: str = "test_sample"
    value: int = 42
    _id: str = "test_id"


# ============================================================================
# PrintExporter Tests
# ============================================================================

class TestPrintExporter:
    """Tests for PrintExporter class."""

    def test_initialization(self, mock_logger):
        """Test PrintExporter initialization."""
        from redb.extractors.database_exporters import PrintExporter

        exporter = PrintExporter(mock_logger, "test_index")

        assert exporter.index_prefix == "test_index"
        assert exporter.log is mock_logger

    def test_export_dataclass(self, mock_logger, capsys):
        """Test exporting a dataclass."""
        from redb.extractors.database_exporters import PrintExporter

        exporter = PrintExporter(mock_logger, "test_index")
        sample = SampleData()

        result = exporter.export(sample)

        assert result is True
        captured = capsys.readouterr()
        assert "test_sample" in captured.out

    def test_export_list_of_dataclasses(self, mock_logger, capsys):
        """Test exporting a list of dataclasses."""
        from redb.extractors.database_exporters import PrintExporter

        exporter = PrintExporter(mock_logger, "test_index")
        samples = [SampleData(name="sample1"), SampleData(name="sample2")]

        result = exporter.export(samples)

        assert result is True
        captured = capsys.readouterr()
        assert "sample1" in captured.out
        assert "sample2" in captured.out

    def test_export_dict(self, mock_logger, capsys):
        """Test exporting a dictionary."""
        from redb.extractors.database_exporters import PrintExporter

        exporter = PrintExporter(mock_logger, "test_index")
        data = {"key": "value", "number": 42}

        result = exporter.export(data)

        assert result is True
        captured = capsys.readouterr()
        assert "key" in captured.out
        assert "value" in captured.out

    def test_export_none(self, mock_logger):
        """Test exporting None."""
        from redb.extractors.database_exporters import PrintExporter

        exporter = PrintExporter(mock_logger, "test_index")

        result = exporter.export(None)

        assert result is True

    def test_export_empty_list(self, mock_logger):
        """Test exporting empty list."""
        from redb.extractors.database_exporters import PrintExporter

        exporter = PrintExporter(mock_logger, "test_index")

        result = exporter.export([])

        assert result is True


# ============================================================================
# ElasticsearchExporter Tests
# ============================================================================

class TestElasticsearchExporter:
    """Tests for ElasticsearchExporter class."""

    def test_initialization(self, mock_logger):
        """Test ElasticsearchExporter initialization."""
        with patch('redb.settings.get_elasticsearch_client') as mock_client:
            mock_client.return_value = Mock()
            from redb.extractors.database_exporters import ElasticsearchExporter

            exporter = ElasticsearchExporter(mock_logger, "test_index")

            assert exporter.index_prefix == "test_index"
            assert exporter.log is mock_logger
            assert exporter.client is not None

    def test_export_dataclass(self, mock_logger):
        """Test exporting a dataclass to Elasticsearch."""
        with patch('redb.settings.get_elasticsearch_client') as mock_get_client:
            mock_client = Mock()
            mock_get_client.return_value = mock_client

            from redb.extractors.database_exporters import ElasticsearchExporter

            exporter = ElasticsearchExporter(mock_logger, "test_index")
            sample = SampleData()

            result = exporter.export(
                sample,
                index="test_index",
                tag="test_tag",
                hashes={"sha256": sample.sha256}
            )

            assert result is True
            mock_client.index.assert_called()

    def test_export_list(self, mock_logger):
        """Test exporting a list to Elasticsearch."""
        with patch('redb.settings.get_elasticsearch_client') as mock_get_client:
            mock_client = Mock()
            mock_get_client.return_value = mock_client

            from redb.extractors.database_exporters import ElasticsearchExporter

            exporter = ElasticsearchExporter(mock_logger, "test_index")
            samples = [SampleData(name="sample1"), SampleData(name="sample2")]

            result = exporter.export(
                samples,
                index="test_index",
                tag="test_tag",
                hashes={"sha256": "test_hash"}
            )

            assert result is True
            # Should be called twice (once per sample)
            assert mock_client.index.call_count == 2

    def test_export_failure(self, mock_logger):
        """Test handling export failure."""
        with patch('redb.settings.get_elasticsearch_client') as mock_get_client:
            mock_client = Mock()
            mock_client.index.side_effect = Exception("Connection failed")
            mock_get_client.return_value = mock_client

            from redb.extractors.database_exporters import ElasticsearchExporter

            exporter = ElasticsearchExporter(mock_logger, "test_index")
            sample = SampleData()

            result = exporter.export(
                sample,
                index="test_index",
                tag="test_tag",
                hashes={"sha256": sample.sha256}
            )

            assert result is False
            mock_logger.error.assert_called()

    def test_export_with_custom_id(self, mock_logger):
        """Test exporting with custom _id field."""
        with patch('redb.settings.get_elasticsearch_client') as mock_get_client:
            mock_client = Mock()
            mock_get_client.return_value = mock_client

            from redb.extractors.database_exporters import ElasticsearchExporter

            exporter = ElasticsearchExporter(mock_logger, "test_index")
            sample = SampleData(_id="custom_id")

            result = exporter.export(
                sample,
                index="test_index",
                tag="test_tag",
                hashes={"sha256": sample.sha256}
            )

            assert result is True


# ============================================================================
# ClickHouseExporter Tests
# ============================================================================

class TestClickHouseExporter:
    """Tests for ClickHouseExporter class."""

    def test_initialization(self, mock_logger):
        """Test ClickHouseExporter initialization."""
        from redb.extractors.database_exporters import ClickHouseExporter

        mock_client = Mock()
        exporter = ClickHouseExporter(mock_logger, "test_index", client=mock_client)

        assert exporter.index_prefix == "test_index"
        assert exporter.log is mock_logger
        assert exporter.client is mock_client

    def test_export_tuple_data(self, mock_logger):
        """Test exporting tuple data to ClickHouse."""
        with patch('redb.settings.create_clickhouse_client') as mock_create:
            mock_client = Mock()
            mock_client.insert.return_value = True
            mock_create.return_value = mock_client

            from redb.extractors.database_exporters import ClickHouseExporter

            exporter = ClickHouseExporter(mock_logger, "test_index")

            data = [["hash123", "sample.exe", 1024]]
            column_names = ["sha256", "name", "size"]
            column_type_names = ["String", "String", "UInt64"]

            result = exporter.export(
                (data, column_names, column_type_names),
                table="test_table"
            )

            assert result is True

    def test_export_multi_table(self, mock_logger):
        """Test exporting multi-table data to ClickHouse."""
        with patch('redb.settings.create_clickhouse_client') as mock_create:
            mock_client = Mock()
            mock_client.insert.return_value = True
            mock_create.return_value = mock_client

            from redb.extractors.database_exporters import ClickHouseExporter

            exporter = ClickHouseExporter(mock_logger, "test_index")

            data = {
                'multi_table': True,
                'table1': {
                    'table': 'test_table1',
                    'data': [["hash123", "sample.exe"]],
                    'column_names': ["sha256", "name"],
                    'column_type_names': ["String", "String"]
                }
            }

            result = exporter.export(data)

            assert result is True

    def test_export_failure(self, mock_logger):
        """Test handling export failure."""
        with patch('redb.settings.create_clickhouse_client') as mock_create:
            mock_client = Mock()
            mock_client.insert.side_effect = Exception("Connection failed")
            mock_create.return_value = mock_client

            from redb.extractors.database_exporters import ClickHouseExporter

            exporter = ClickHouseExporter(mock_logger, "test_index")

            data = [["hash123", "sample.exe", 1024]]
            column_names = ["sha256", "name", "size"]
            column_type_names = ["String", "String", "UInt64"]

            result = exporter.export(
                (data, column_names, column_type_names),
                table="test_table"
            )

            assert result is False

    def test_export_missing_table(self, mock_logger):
        """Test export without table name raises error."""
        with patch('redb.settings.create_clickhouse_client') as mock_create:
            mock_client = Mock()
            mock_create.return_value = mock_client

            from redb.extractors.database_exporters import ClickHouseExporter

            exporter = ClickHouseExporter(mock_logger, "test_index")

            data = [["hash123", "sample.exe", 1024]]
            column_names = ["sha256", "name", "size"]
            column_type_names = ["String", "String", "UInt64"]

            result = exporter.export(
                (data, column_names, column_type_names)
                # Missing table parameter
            )

            assert result is False

    def test_get_client(self, mock_logger):
        """Test get_client method."""
        from redb.extractors.database_exporters import ClickHouseExporter

        mock_client = Mock()
        exporter = ClickHouseExporter(mock_logger, "test_index", client=mock_client)

        result = exporter.get_client()

        assert result is mock_client

    def test_get_client_creates_new(self, mock_logger):
        """Test get_client creates new client if none exists."""
        with patch('redb.settings.create_clickhouse_client') as mock_create:
            mock_new_client = Mock()
            mock_create.return_value = mock_new_client

            from redb.extractors.database_exporters import ClickHouseExporter

            exporter = ClickHouseExporter(mock_logger, "test_index")

            result = exporter.get_client()

            assert result is mock_new_client


# ============================================================================
# DatabaseExporter Abstract Base Class Tests
# ============================================================================

class TestDatabaseExporter:
    """Tests for DatabaseExporter abstract base class."""

    def test_cannot_instantiate_abstract(self):
        """Test that DatabaseExporter cannot be instantiated directly."""
        from redb.extractors.database_exporters import DatabaseExporter

        with pytest.raises(TypeError):
            DatabaseExporter()

    def test_subclass_must_implement_export(self):
        """Test that subclasses must implement export method."""
        from redb.extractors.database_exporters import DatabaseExporter

        # Define incomplete subclass
        class IncompleteExporter(DatabaseExporter):
            pass

        with pytest.raises(TypeError):
            IncompleteExporter()


# ============================================================================
# Null/Edge Case Tests
# ============================================================================

class TestExporterEdgeCases:
    """Tests for edge cases in exporters."""

    def test_print_exporter_with_complex_nested_data(self, mock_logger, capsys):
        """Test PrintExporter with complex nested data."""
        from redb.extractors.database_exporters import PrintExporter

        exporter = PrintExporter(mock_logger, "test_index")
        data = {
            "level1": {
                "level2": {
                    "level3": [1, 2, 3]
                }
            },
            "array": [{"a": 1}, {"b": 2}]
        }

        result = exporter.export(data)

        assert result is True
        captured = capsys.readouterr()
        assert "level1" in captured.out

    def test_clickhouse_null_handling(self, mock_logger):
        """Test ClickHouse exporter handles null values."""
        with patch('redb.settings.create_clickhouse_client') as mock_create:
            mock_client = Mock()
            mock_client.insert.return_value = True
            mock_create.return_value = mock_client

            from redb.extractors.database_exporters import ClickHouseExporter

            exporter = ClickHouseExporter(mock_logger, "test_index")

            # Multi-table data with null values
            data = {
                'multi_table': True,
                'table1': {
                    'table': 'test_table',
                    'data': [[None, "sample.exe", None]],
                    'column_names': ["sha256", "name", "size"],
                    'column_type_names': ["Nullable(String)", "String", "Nullable(UInt64)"]
                }
            }

            result = exporter.export(data)

            # Should handle nulls appropriately
            assert result is True

    def test_clickhouse_array_handling(self, mock_logger):
        """Test ClickHouse exporter handles array types."""
        with patch('redb.settings.create_clickhouse_client') as mock_create:
            mock_client = Mock()
            mock_client.insert.return_value = True
            mock_create.return_value = mock_client

            from redb.extractors.database_exporters import ClickHouseExporter

            exporter = ClickHouseExporter(mock_logger, "test_index")

            data = {
                'multi_table': True,
                'table1': {
                    'table': 'test_table',
                    'data': [["hash", ["tag1", "tag2"]]],
                    'column_names': ["sha256", "tags"],
                    'column_type_names': ["String", "Array(String)"]
                }
            }

            result = exporter.export(data)

            assert result is True


# ============================================================================
# Type Conversion Tests
# ============================================================================

class TestExporterTypeConversions:
    """Tests for type conversions in exporters."""

    def test_clickhouse_datetime_handling(self, mock_logger):
        """Test ClickHouse exporter handles datetime values."""
        with patch('redb.settings.create_clickhouse_client') as mock_create:
            mock_client = Mock()
            mock_client.insert.return_value = True
            mock_create.return_value = mock_client

            from redb.extractors.database_exporters import ClickHouseExporter

            exporter = ClickHouseExporter(mock_logger, "test_index")

            now = datetime.now(timezone.utc)
            data = {
                'multi_table': True,
                'table1': {
                    'table': 'test_table',
                    'data': [["hash", now]],
                    'column_names': ["sha256", "timestamp"],
                    'column_type_names': ["String", "DateTime64(3, 'UTC')"]
                }
            }

            result = exporter.export(data)

            assert result is True

    def test_print_exporter_datetime_serialization(self, mock_logger, capsys):
        """Test PrintExporter handles datetime serialization."""
        from redb.extractors.database_exporters import PrintExporter

        exporter = PrintExporter(mock_logger, "test_index")
        now = datetime.now(timezone.utc)
        data = {"timestamp": now, "name": "test"}

        result = exporter.export(data)

        assert result is True
        captured = capsys.readouterr()
        assert "timestamp" in captured.out


# ============================================================================
# Connection Context Manager Tests
# ============================================================================

class TestClickHouseConnectionManager:
    """Tests for ClickHouse connection context manager."""

    def test_clickhouse_connection_context(self, mock_logger):
        """Test clickhouse_connection context manager."""
        with patch('redb.settings.create_clickhouse_client') as mock_create:
            mock_client = Mock()
            mock_create.return_value = mock_client

            from redb.extractors.database_exporters import ClickHouseExporter

            exporter = ClickHouseExporter(mock_logger, "test_index")

            with exporter.clickhouse_connection() as client:
                assert client is mock_client

            # Client should be closed after context exits
            mock_client.close.assert_called()

    def test_clickhouse_connection_close_on_error(self, mock_logger):
        """Test client is closed even if operation fails."""
        with patch('redb.settings.create_clickhouse_client') as mock_create:
            mock_client = Mock()
            mock_create.return_value = mock_client

            from redb.extractors.database_exporters import ClickHouseExporter

            exporter = ClickHouseExporter(mock_logger, "test_index")

            try:
                with exporter.clickhouse_connection() as client:
                    raise ValueError("Test error")
            except ValueError:
                pass

            # Client should still be closed
            mock_client.close.assert_called()