nomy-data-models 0.35.6

Data model definitions for Nomy wallet analysis data processing
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230

"""Tests for the wallet_state module."""

import uuid
from datetime import datetime

import pytest

from nomy_data_models.models.wallet_state import DataState, SyncState, WalletState


@pytest.fixture
def empty_wallet_state():
    """Fixture providing a WalletState instance with empty data states.

    Returns:
        WalletState: A WalletState instance with empty data states
    """
    wallet_state = WalletState()
    wallet_state.id = uuid.uuid4()
    wallet_state.wallet_address = "0x1234567890123456789012345678901234567890"
    wallet_state.chain_id = 1
    wallet_state.raw_data_state = DataState.EMPTY
    wallet_state.enriched_data_state = DataState.EMPTY
    wallet_state.sync_state = SyncState.PENDING
    return wallet_state


@pytest.fixture
def partial_wallet_state():
    """Fixture providing a WalletState instance with partial data states and block data.

    Returns:
        WalletState: A WalletState instance with partial data states and block data
    """
    wallet_state = WalletState()
    wallet_state.id = uuid.uuid4()
    wallet_state.wallet_address = "0x1234567890123456789012345678901234567890"
    wallet_state.chain_id = 1
    wallet_state.raw_data_state = DataState.PARTIAL
    wallet_state.enriched_data_state = DataState.PARTIAL
    wallet_state.sync_state = SyncState.SYNCED
    wallet_state.raw_first_block = 1000000
    wallet_state.raw_last_block = 2000000
    wallet_state.enriched_first_block = 1000000
    wallet_state.enriched_last_block = 1500000
    wallet_state.last_sync_at = datetime.now()
    return wallet_state


class TestDataState:
    """Test cases for DataState enum."""

    def test_data_state_values(self):
        """Test that the DataState enum has the expected values."""
        assert DataState.EMPTY.value == "empty", "EMPTY value should be 'empty'"
        assert DataState.PARTIAL.value == "partial", "PARTIAL value should be 'partial'"
        assert (
            DataState.COMPLETE.value == "complete"
        ), "COMPLETE value should be 'complete'"
        assert DataState.ERROR.value == "error", "ERROR value should be 'error'"

    def test_data_state_comparison(self):
        """Test that the DataState enum values can be compared."""
        assert DataState.EMPTY == DataState.EMPTY, "EMPTY should equal itself"
        assert DataState.EMPTY != DataState.PARTIAL, "EMPTY should not equal PARTIAL"
        assert DataState.PARTIAL == DataState.PARTIAL, "PARTIAL should equal itself"
        assert DataState.COMPLETE == DataState.COMPLETE, "COMPLETE should equal itself"
        assert DataState.ERROR == DataState.ERROR, "ERROR should equal itself"


class TestSyncState:
    """Test cases for SyncState enum."""

    def test_sync_state_values(self):
        """Test that the SyncState enum has the expected values."""
        assert SyncState.PENDING.value == "pending", "PENDING value should be 'pending'"
        assert SyncState.SYNCING.value == "syncing", "SYNCING value should be 'syncing'"
        assert SyncState.SYNCED.value == "synced", "SYNCED value should be 'synced'"
        assert SyncState.FAILED.value == "failed", "FAILED value should be 'failed'"

    def test_sync_state_comparison(self):
        """Test that the SyncState enum values can be compared."""
        assert SyncState.PENDING == SyncState.PENDING, "PENDING should equal itself"
        assert (
            SyncState.PENDING != SyncState.SYNCING
        ), "PENDING should not equal SYNCING"
        assert SyncState.SYNCING == SyncState.SYNCING, "SYNCING should equal itself"
        assert SyncState.SYNCED == SyncState.SYNCED, "SYNCED should equal itself"
        assert SyncState.FAILED == SyncState.FAILED, "FAILED should equal itself"


class TestWalletState:
    """Test cases for WalletState model."""

    def test_wallet_state_creation(self, empty_wallet_state):
        """Test creating a WalletState instance with empty data states.

        Args:
            empty_wallet_state: Fixture providing a WalletState instance with empty data states
        """
        # Verify the instance was created correctly
        assert empty_wallet_state.id is not None, "ID should be set"
        assert (
            empty_wallet_state.wallet_address
            == "0x1234567890123456789012345678901234567890"
        ), "Wallet address should match"
        assert empty_wallet_state.chain_id == 1, "Chain ID should be 1"
        assert (
            empty_wallet_state.raw_data_state == DataState.EMPTY
        ), "Raw data state should be EMPTY"
        assert (
            empty_wallet_state.enriched_data_state == DataState.EMPTY
        ), "Enriched data state should be EMPTY"
        assert (
            empty_wallet_state.sync_state == SyncState.PENDING
        ), "Sync state should be PENDING"

    def test_wallet_state_with_block_data(self, partial_wallet_state):
        """Test creating a WalletState instance with partial data states and block data.

        Args:
            partial_wallet_state: Fixture providing a WalletState instance with partial data states
        """
        # Verify the instance was created correctly
        assert partial_wallet_state.id is not None, "ID should be set"
        assert (
            partial_wallet_state.wallet_address
            == "0x1234567890123456789012345678901234567890"
        ), "Wallet address should match"
        assert partial_wallet_state.chain_id == 1, "Chain ID should be 1"
        assert (
            partial_wallet_state.raw_data_state == DataState.PARTIAL
        ), "Raw data state should be PARTIAL"
        assert (
            partial_wallet_state.enriched_data_state == DataState.PARTIAL
        ), "Enriched data state should be PARTIAL"
        assert (
            partial_wallet_state.sync_state == SyncState.SYNCED
        ), "Sync state should be SYNCED"
        assert (
            partial_wallet_state.raw_first_block == 1000000
        ), "Raw first block should be 1000000"
        assert (
            partial_wallet_state.raw_last_block == 2000000
        ), "Raw last block should be 2000000"
        assert (
            partial_wallet_state.enriched_first_block == 1000000
        ), "Enriched first block should be 1000000"
        assert (
            partial_wallet_state.enriched_last_block == 1500000
        ), "Enriched last block should be 1500000"
        assert (
            partial_wallet_state.last_sync_at is not None
        ), "Last sync timestamp should be set"

    def test_wallet_state_repr(self):
        """Test the string representation of a WalletState."""
        # Create a WalletState instance
        wallet_state = WalletState()

        # Set required attributes
        wallet_state.wallet_address = "0x1234567890123456789012345678901234567890"
        wallet_state.chain_id = 1
        wallet_state.sync_state = SyncState.SYNCING

        # Verify the string representation
        expected_repr = (
            "<WalletState(wallet=0x123456..., " "chain_id=1, " "sync_state=syncing)>"
        )
        assert (
            str(wallet_state) == expected_repr
        ), "String representation should match expected format"

    def test_wallet_state_db_integration(self, session):
        """Test database integration with the WalletState model.

        Args:
            session: SQLAlchemy session fixture
        """
        # Create a new WalletState instance
        wallet_state = WalletState()
        wallet_state.wallet_address = "0x1234567890123456789012345678901234567890"
        wallet_state.chain_id = 1
        wallet_state.raw_data_state = DataState.PARTIAL
        wallet_state.enriched_data_state = DataState.EMPTY
        wallet_state.sync_state = SyncState.SYNCING
        wallet_state.raw_first_block = 1000000
        wallet_state.raw_last_block = 2000000
        wallet_state.last_sync_at = datetime.now()

        # Add to session and commit
        session.add(wallet_state)
        session.commit()

        # Verify the wallet state was saved to the database
        retrieved = (
            session.query(WalletState)
            .filter_by(
                wallet_address="0x1234567890123456789012345678901234567890", chain_id=1
            )
            .first()
        )
        assert retrieved is not None, "Wallet state should be retrievable from database"
        assert retrieved.id == wallet_state.id, "Retrieved wallet state ID should match"
        assert (
            retrieved.wallet_address == "0x1234567890123456789012345678901234567890"
        ), "Retrieved wallet address should match"
        assert retrieved.chain_id == 1, "Retrieved chain ID should match"
        assert (
            retrieved.raw_data_state == DataState.PARTIAL
        ), "Retrieved raw data state should match"
        assert (
            retrieved.enriched_data_state == DataState.EMPTY
        ), "Retrieved enriched data state should match"
        assert (
            retrieved.sync_state == SyncState.SYNCING
        ), "Retrieved sync state should match"
        assert (
            retrieved.raw_first_block == 1000000
        ), "Retrieved raw first block should match"
        assert (
            retrieved.raw_last_block == 2000000
        ), "Retrieved raw last block should match"
        assert (
            retrieved.last_sync_at is not None
        ), "Retrieved last sync timestamp should be set"


if __name__ == "__main__":
    pytest.main(["-v", __file__])