testStorageHandler.py 8.97 KB
Newer Older
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15
#
# Copyright (C) 2009  Nexedi SA
# 
# This program is free software; you can redistribute it and/or
# modify it under the terms of the GNU General Public License
# as published by the Free Software Foundation; either version 2
# of the License, or (at your option) any later version.
# 
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program; if not, write to the Free Software
16
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
17 18 19

import os
import unittest
20
from neo import logging
21 22 23
from struct import pack, unpack
from mock import Mock
from collections import deque
24
from neo.tests import NeoTestBase
25
from neo.storage.app import Application
26
from neo.storage.handlers.storage import StorageOperationHandler
27
from neo.protocol import Packets, Packet, INVALID_PARTITION
28
from neo.protocol import INVALID_TID, INVALID_OID, INVALID_SERIAL
29 30 31 32 33 34

class StorageStorageHandlerTests(NeoTestBase):

    def checkHandleUnexpectedPacket(self, _call, _msg_type, _listening=True, **kwargs):
        conn = Mock({ 
            "getAddress" : ("127.0.0.1", self.master_port), 
35
            "isServer": _listening,    
36 37 38 39 40 41 42 43 44
        })
        packet = Packet(msg_type=_msg_type)
        # hook
        self.operation.peerBroken = lambda c: c.peerBrokendCalled()
        self.checkUnexpectedPacketRaised(_call, conn=conn, packet=packet, **kwargs)

    def setUp(self):
        self.prepareDatabase(number=1)
        # create an application object
45 46
        config = self.getStorageConfiguration(master_number=1)
        self.app = Application(**config)
47 48 49 50
        self.app.transaction_dict = {}
        self.app.store_lock_dict = {}
        self.app.load_lock_dict = {}
        self.app.event_queue = deque()
51 52
        for address in self.app.master_node_list:
            self.app.nm.createMaster(address=address)
53 54 55 56
        # handler
        self.operation = StorageOperationHandler(self.app)
        # set pmn
        self.master_uuid = self.getNewUUID()
57
        pmn = self.app.nm.getMasterList()[0]
58 59 60 61 62 63 64
        pmn.setUUID(self.master_uuid)
        self.app.primary_master_node = pmn
        self.master_port = 10010

    def tearDown(self):
        NeoTestBase.tearDown(self)

65
    def test_18_askTransactionInformation1(self):
66 67
        # transaction does not exists
        conn = Mock({ })
68 69
        packet = Packets.AskTransactionInformation()
        packet.setId(0)
70
        self.operation.askTransactionInformation(conn, packet, INVALID_TID)
71 72
        self.checkErrorPacket(conn)

73
    def test_18_askTransactionInformation2(self):
74 75
        # answer
        conn = Mock({ })
76 77
        packet = Packets.AskTransactionInformation()
        packet.setId(0)
78 79
        dm = Mock({ "getTransaction": (INVALID_TID, 'user', 'desc', '', ), })
        self.app.dm = dm
80
        self.operation.askTransactionInformation(conn, packet, INVALID_TID)
81 82
        self.checkAnswerTransactionInformation(conn)

83
    def test_24_askObject1(self):
84 85 86
        # delayed response
        conn = Mock({})
        self.app.dm = Mock()
87
        packet = Packets.AskObject()
88 89
        self.app.load_lock_dict[INVALID_OID] = object()
        self.assertEquals(len(self.app.event_queue), 0)
90
        self.operation.askObject(conn, packet, 
91 92 93 94 95 96 97
            oid=INVALID_OID, 
            serial=INVALID_SERIAL, 
            tid=INVALID_TID)
        self.assertEquals(len(self.app.event_queue), 1)
        self.checkNoPacketSent(conn)
        self.assertEquals(len(self.app.dm.mockGetNamedCalls('getObject')), 0)

98
    def test_24_askObject2(self):
99 100 101
        # invalid serial / tid / packet not found
        self.app.dm = Mock({'getObject': None})
        conn = Mock({})
102 103
        packet = Packets.AskObject()
        packet.setId(0)
104
        self.assertEquals(len(self.app.event_queue), 0)
105
        self.operation.askObject(conn, packet, 
106 107 108 109 110 111
            oid=INVALID_OID, 
            serial=INVALID_SERIAL, 
            tid=INVALID_TID)
        calls = self.app.dm.mockGetNamedCalls('getObject')
        self.assertEquals(len(self.app.event_queue), 0)
        self.assertEquals(len(calls), 1)
Grégory Wisniewski's avatar
Grégory Wisniewski committed
112
        calls[0].checkArgs(INVALID_OID, INVALID_TID, INVALID_TID)
113 114
        self.checkErrorPacket(conn)

115
    def test_24_askObject3(self):
116 117 118
        # object found => answer
        self.app.dm = Mock({'getObject': ('', '', 0, 0, '', )})
        conn = Mock({})
119 120
        packet = Packets.AskObject()
        packet.setId(0)
121
        self.assertEquals(len(self.app.event_queue), 0)
122
        self.operation.askObject(conn, packet, 
123 124 125 126 127 128
            oid=INVALID_OID, 
            serial=INVALID_SERIAL, 
            tid=INVALID_TID)
        self.assertEquals(len(self.app.event_queue), 0)
        self.checkAnswerObject(conn)

129
    def test_25_askTIDs1(self):
130 131 132 133 134
        # invalid offsets => error
        app = self.app
        app.pt = Mock()
        app.dm = Mock()
        conn = Mock({})
135
        packet = Packets.AskTIDs()
136
        self.checkProtocolErrorRaised(self.operation.askTIDs, conn, packet, 1, 1, None)
137 138 139
        self.assertEquals(len(app.pt.mockGetNamedCalls('getCellList')), 0)
        self.assertEquals(len(app.dm.mockGetNamedCalls('getTIDList')), 0)

140
    def test_25_askTIDs2(self):
141 142
        # well case => answer
        conn = Mock({})
143 144
        packet = Packets.AskTIDs()
        packet.setId(0)
145
        self.app.dm = Mock({'getTIDList': (INVALID_TID, )})
146
        self.app.pt = Mock({'getPartitions': 1})
147
        self.operation.askTIDs(conn, packet, 1, 2, 1)
148 149 150 151 152
        calls = self.app.dm.mockGetNamedCalls('getTIDList')
        self.assertEquals(len(calls), 1)
        calls[0].checkArgs(1, 1, 1, [1, ])
        self.checkAnswerTids(conn)

153
    def test_25_askTIDs3(self):
154 155
        # invalid partition => answer usable partitions
        conn = Mock({})
156 157
        packet = Packets.AskTIDs()
        packet.setId(0)
158 159
        cell = Mock({'getUUID':self.app.uuid})
        self.app.dm = Mock({'getTIDList': (INVALID_TID, )})
160
        self.app.pt = Mock({'getCellList': (cell, ), 'getPartitions': 1})
161
        self.operation.askTIDs(conn, packet, 1, 2, INVALID_PARTITION)
162 163 164 165 166 167
        self.assertEquals(len(self.app.pt.mockGetNamedCalls('getCellList')), 1)
        calls = self.app.dm.mockGetNamedCalls('getTIDList')
        self.assertEquals(len(calls), 1)
        calls[0].checkArgs(1, 1, 1, [0, ])
        self.checkAnswerTids(conn)

168
    def test_26_askObjectHistory1(self):
169 170 171 172
        # invalid offsets => error
        app = self.app
        app.dm = Mock()
        conn = Mock({})
173 174
        packet = Packets.AskObjectHistory()
        packet.setId(0)
175
        self.checkProtocolErrorRaised(self.operation.askObjectHistory, conn, packet, 1, 1, None)
176 177
        self.assertEquals(len(app.dm.mockGetNamedCalls('getObjectHistory')), 0)

178
    def test_26_askObjectHistory2(self):
179
        # first case: empty history
180 181
        packet = Packets.AskObjectHistory()
        packet.setId(0)
182 183
        conn = Mock({})
        self.app.dm = Mock({'getObjectHistory': None})
184
        self.operation.askObjectHistory(conn, packet, INVALID_OID, 1, 2)
185 186 187 188
        self.checkAnswerObjectHistory(conn)
        # second case: not empty history
        conn = Mock({})
        self.app.dm = Mock({'getObjectHistory': [('', 0, ), ]})
189
        self.operation.askObjectHistory(conn, packet, INVALID_OID, 1, 2)
190 191
        self.checkAnswerObjectHistory(conn)

192
    def test_25_askOIDs1(self):
193 194 195 196 197
        # invalid offsets => error
        app = self.app
        app.pt = Mock()
        app.dm = Mock()
        conn = Mock({})
198 199
        packet = Packets.AskOIDs()
        packet.setId(0)
200
        self.checkProtocolErrorRaised(self.operation.askOIDs, conn, packet, 1, 1, None)
201 202 203
        self.assertEquals(len(app.pt.mockGetNamedCalls('getCellList')), 0)
        self.assertEquals(len(app.dm.mockGetNamedCalls('getOIDList')), 0)

204
    def test_25_askOIDs2(self):
205 206
        # well case > answer OIDs
        conn = Mock({})
207 208
        packet = Packets.AskOIDs()
        packet.setId(0)
209
        self.app.pt = Mock({'getPartitions': 1})
210
        self.app.dm = Mock({'getOIDList': (INVALID_OID, )})
211
        self.operation.askOIDs(conn, packet, 1, 2, 1)
212 213 214 215 216
        calls = self.app.dm.mockGetNamedCalls('getOIDList')
        self.assertEquals(len(calls), 1)
        calls[0].checkArgs(1, 1, 1, [1, ])
        self.checkAnswerOids(conn)

217
    def test_25_askOIDs3(self):
218 219
        # invalid partition => answer usable partitions
        conn = Mock({})
220 221
        packet = Packets.AskOIDs()
        packet.setId(0)
222 223
        cell = Mock({'getUUID':self.app.uuid})
        self.app.dm = Mock({'getOIDList': (INVALID_OID, )})
224
        self.app.pt = Mock({'getCellList': (cell, ), 'getPartitions': 1})
225
        self.operation.askOIDs(conn, packet, 1, 2, INVALID_PARTITION)
226 227 228 229 230 231 232 233 234
        self.assertEquals(len(self.app.pt.mockGetNamedCalls('getCellList')), 1)
        calls = self.app.dm.mockGetNamedCalls('getOIDList')
        self.assertEquals(len(calls), 1)
        calls[0].checkArgs(1, 1, 1, [0, ])
        self.checkAnswerOids(conn)


if __name__ == "__main__":
    unittest.main()