test_slapproxy.py 68.3 KB
Newer Older
1
# -*- coding: utf-8 -*-
2
# vim: set et sts=2:
3 4
##############################################################################
#
5
# Copyright (c) 2012, 2013, 2014 Vifib SARL and Contributors.
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
# All Rights Reserved.
#
# WARNING: This program as such is intended to be used by professional
# programmers who take the whole responsibility of assessing all potential
# consequences resulting from its eventual inadequacies and bugs
# End users who are looking for a ready-to-use solution with commercial
# guarantees and support are strongly advised to contract a Free Software
# Service Company
#
# 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 3
# 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
# Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
#
##############################################################################

Bryton Lacquement's avatar
Bryton Lacquement committed
31 32
import six
from six.moves import configparser
33 34 35
import os
import logging
import shutil
36
import socket
37 38 39 40
try:
  import subprocess32 as subprocess
except ImportError:
  import subprocess
41
import sys
42
import tempfile
43
import time
44
import unittest
45
import mock
46

47 48
import slapos.proxy
import slapos.proxy.views as views
49
import slapos.slap
50
import slapos.slap.slap
Bryton Lacquement's avatar
Bryton Lacquement committed
51
from slapos.util import loads, dumps, sqlite_connect, bytes2str
52

53 54 55
import sqlite3
import pkg_resources

56

57 58 59
class WrongFormat(Exception):
  pass

60 61

class ProxyOption(object):
62 63 64 65
  """
  Will simulate options given to slapproxy
  """
  def __init__(self, proxy_db):
66 67
    self.verbose = True
    self.database_uri = proxy_db
68 69 70
    self.console = False
    self.log_file = None

71 72

class BasicMixin(object):
73
  def setUp(self):
74 75 76
    """
    Will set files and start slapproxy
    """
77 78 79 80 81
    self._tempdir = tempfile.mkdtemp()
    logging.basicConfig(level=logging.DEBUG)
    self.setFiles()
    self.startProxy()

82
  def createSlapOSConfigurationFile(self):
Bryton Lacquement's avatar
Bryton Lacquement committed
83 84
    with open(self.slapos_cfg, 'w') as f:
      f.write("""[slapos]
85 86 87 88 89 90 91 92
software_root = %(tempdir)s/opt/slapgrid
instance_root = %(tempdir)s/srv/slapgrid
master_url = %(proxyaddr)s
computer_id = computer
[slapproxy]
host = 127.0.0.1
port = 8080
database_uri = %(tempdir)s/lib/proxy.db
93
""" % {'tempdir': self._tempdir, 'proxyaddr': self.proxyaddr})
94 95 96 97 98 99 100 101 102 103

  def setFiles(self):
    """
    Set environment to run slapproxy
    """
    self.slapos_cfg = os.path.join(self._tempdir, 'slapos.cfg')
    self.proxy_db = os.path.join(self._tempdir, 'lib', 'proxy.db')
    self.proxyaddr = 'http://localhost:80/'
    self.computer_id = 'computer'
    self.createSlapOSConfigurationFile()
104
    for directory in ['opt', 'srv', 'lib']:
105
      path = os.path.join(self._tempdir, directory)
106 107 108
      os.mkdir(path)

  def startProxy(self):
109 110 111
    """
    Set config for slapproxy and start it
    """
112
    conf = slapos.proxy.ProxyConfig(logger=logging.getLogger())
Bryton Lacquement's avatar
Bryton Lacquement committed
113
    configp = configparser.SafeConfigParser()
114 115 116
    configp.read(self.slapos_cfg)
    conf.mergeConfig(ProxyOption(self.proxy_db), configp)
    conf.setConfig()
117
    views.app.config['TESTING'] = True
118
    slapos.proxy.setupFlaskConfiguration(conf)
119

120
    self.app_config = views.app.config
121 122
    self.app = views.app.test_client()

123
  def add_free_partition(self, partition_amount, computer_id=None):
124 125 126 127
    """
    Will simulate a slapformat first run
    and create "partition_amount" partitions
    """
128 129
    if not computer_id:
      computer_id = self.computer_id
130
    computer_dict = {
131
        'reference': computer_id,
132 133
        'address': '12.34.56.78',
        'netmask': '255.255.255.255',
134 135 136 137 138
        'partition_list': [],
    }
    for i in range(partition_amount):
      partition_example = {
          'reference': 'slappart%s' % i,
139 140 141 142 143
          'address_list': [
              {'addr': '1.2.3.4', 'netmask': '255.255.255.255'},
              {'addr': '4.3.2.1', 'netmask': '255.255.255.255'}
           ],
           'tap': {'name': 'tap0'},
144
      }
145 146
      computer_dict['partition_list'].append(partition_example)

147 148
    request_dict = {
        'computer_id': self.computer_id,
Bryton Lacquement's avatar
Bryton Lacquement committed
149
        'xml': dumps(computer_dict),
150
    }
151
    rv = self.app.post('/loadComputerConfigurationFromXML',
152
                  data=request_dict)
153
    self.assertEqual(rv._status_code, 200)
154

155
  def tearDown(self):
156 157 158
    """
    Remove files generated for test
    """
159
    shutil.rmtree(self._tempdir, True)
160
    views.is_schema_already_executed = False
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
class TestLoadComputerConfiguration(BasicMixin, unittest.TestCase):
  """tests /loadComputerConfigurationFromXML the endpoint for format
  """
  def test_loadComputerConfigurationFromXML_remove_partitions(self):
    computer_dict = {
        'reference': self.computer_id,
        'address': '12.34.56.78',
        'netmask': '255.255.255.255',
        'partition_list': [
            {
                'reference': 'slappart1',
                'address_list': [
                    {
                        'addr': '1.2.3.4',
                        'netmask': '255.255.255.255'
                    },
                ],
                'tap': {'name': 'tap0'},
            }
        ],
    }
    rv = self.app.post('/loadComputerConfigurationFromXML', data={
        'computer_id': self.computer_id,
        'xml': dumps(computer_dict),
    })
    self.assertEqual(rv._status_code, 200)
    # call again with different partition reference, old partition will be removed
    # and a new partition will be used.
    computer_dict['partition_list'][0]['reference'] = 'something else'
    rv = self.app.post('/loadComputerConfigurationFromXML', data={
        'computer_id': self.computer_id,
        'xml': dumps(computer_dict),
    })
    self.assertEqual(rv._status_code, 200)
    computer = loads(
        self.app.get('/getFullComputerInformation', query_string={'computer_id': self.computer_id}).data)
    self.assertEqual(
        ['something else'],
        [p.getId() for p in computer._computer_partition_list])


204
class TestInformation(BasicMixin, unittest.TestCase):
205 206 207
  """
  Test Basic response of slapproxy
  """
208

209
  def test_getComputerInformation(self):
210 211 212 213
    """
    Check that getComputerInformation return a Computer
    and database is generated
    """
214
    rv = self.app.get('/getComputerInformation?computer_id=%s' % self.computer_id)
215
    self.assertIsInstance(
Bryton Lacquement's avatar
Bryton Lacquement committed
216
        loads(rv.data),
217
        slapos.slap.Computer)
218 219
    self.assertTrue(os.path.exists(self.proxy_db))

220
  def test_getFullComputerInformation(self):
221 222 223 224
    """
    Check that getFullComputerInformation return a Computer
    and database is generated
    """
225
    rv = self.app.get('/getFullComputerInformation?computer_id=%s' % self.computer_id)
226
    self.assertIsInstance(
Bryton Lacquement's avatar
Bryton Lacquement committed
227
        loads(rv.data),
228
        slapos.slap.Computer)
229 230
    self.assertTrue(os.path.exists(self.proxy_db))

231
  def test_getComputerInformation_wrong_computer(self):
232 233 234 235
    """
    Test that computer information won't be given to a requester different
    from the one specified
    """
236
    with self.assertRaises(slapos.slap.NotFoundError):
237
      self.app.get('/getComputerInformation?computer_id=%s42' % self.computer_id)
238

239
  def test_partition_are_empty(self):
240 241 242 243
    """
    Test that empty partition are empty :)
    """
    self.add_free_partition(10)
244
    rv = self.app.get('/getFullComputerInformation?computer_id=%s' % self.computer_id)
Bryton Lacquement's avatar
Bryton Lacquement committed
245
    computer = loads(rv.data)
246 247 248 249 250
    for slap_partition in computer._computer_partition_list:
        self.assertIsNone(slap_partition._software_release_document)
        self.assertEqual(slap_partition._requested_state, 'destroyed')
        self.assertEqual(slap_partition._need_modification, 0)

251 252 253 254 255 256 257 258 259 260 261 262 263
  def test_getSoftwareReleaseListFromSoftwareProduct_software_product_reference(self):
    """
    Check that calling getSoftwareReleaseListFromSoftwareProduct() in slapproxy
    using a software_product_reference as parameter behaves correctly.
    """
    software_product_reference = 'my_product'
    software_release_url = 'my_url'
    self.app_config['software_product_list'] = {
        software_product_reference: software_release_url
    }
    response = self.app.get('/getSoftwareReleaseListFromSoftwareProduct'
                            '?software_product_reference=%s' %\
                            software_product_reference)
Bryton Lacquement's avatar
Bryton Lacquement committed
264
    software_release_url_list = loads(response.data)
265 266 267 268 269 270 271 272 273 274 275 276 277 278
    self.assertEqual(
        software_release_url_list,
        [software_release_url]
    )

  def test_getSoftwareReleaseListFromSoftwareProduct_noSoftwareProduct(self):
    """
    Check that calling getSoftwareReleaseListFromSoftwareProduct() in slapproxy
    using a software_product_reference that doesn't exist as parameter
    returns empty list.
    """
    self.app_config['software_product_list'] = {'random': 'random'}
    response = self.app.get('/getSoftwareReleaseListFromSoftwareProduct'
                            '?software_product_reference=idonotexist')
Bryton Lacquement's avatar
Bryton Lacquement committed
279
    software_release_url_list = loads(response.data)
280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307
    self.assertEqual(
        software_release_url_list,
        []
    )

  def test_getSoftwareReleaseListFromSoftwareProduct_bothParameter(self):
    """
    Test that a call to getSoftwareReleaseListFromSoftwareProduct with no
    parameter raises
    """
    self.assertRaises(
        AssertionError,
       self.app.get,
       '/getSoftwareReleaseListFromSoftwareProduct'
       '?software_product_reference=foo'
       '&software_release_url=bar'
    )

  def test_getSoftwareReleaseListFromSoftwareProduct_noParameter(self):
    """
    Test that a call to getSoftwareReleaseListFromSoftwareProduct with both
    software_product_reference and software_release_url parameters raises
    """
    self.assertRaises(
        AssertionError,
        self.app.get, '/getSoftwareReleaseListFromSoftwareProduct'
    )

308 309 310 311 312 313 314
  def test_getComputerPartitionCertificate(self):
    """
    Tests that getComputerPartitionCertificate method is implemented in slapproxy.
    """
    rv = self.app.get(
      '/getComputerPartitionCertificate?computer_id=%s&computer_partition_id=%s' % (
      self.computer_id, 'slappart0'))
Bryton Lacquement's avatar
Bryton Lacquement committed
315
    response = loads(rv.data)
316
    self.assertEqual({'certificate': '', 'key': ''}, response)
317

318 319 320 321 322
  def test_computerBang(self):
    """
    Tests that computerBang method is implemented in slapproxy.
    """
    rv = self.app.post( '/computerBang?computer_id=%s' % ( self.computer_id))
Bryton Lacquement's avatar
Bryton Lacquement committed
323
    response = loads(rv.data)
324
    self.assertEqual('', response)
325

326
class MasterMixin(BasicMixin, unittest.TestCase):
327 328 329
  """
  Define advanced tool for test proxy simulating behavior slap library tools
  """
330
  def _requestComputerPartition(self, software_release, software_type, partition_reference,
331
              partition_id=None,
332 333
              shared=False, partition_parameter_kw=None, filter_kw=None,
              state=None):
334
    """
335
    Check parameters, call requestComputerPartition server method and return result
336
    """
337 338 339 340
    if partition_parameter_kw is None:
      partition_parameter_kw = {}
    if filter_kw is None:
      filter_kw = {}
341
   # Let's enforce a default software type
342 343 344
    if software_type is None:
      software_type = 'default'

345 346
    request_dict = {
        'computer_id': self.computer_id,
347 348 349 350
        'computer_partition_id': partition_id,
        'software_release': software_release,
        'software_type': software_type,
        'partition_reference': partition_reference,
Bryton Lacquement's avatar
Bryton Lacquement committed
351 352 353 354
        'shared_xml': dumps(shared),
        'partition_parameter_xml': dumps(partition_parameter_kw),
        'filter_xml': dumps(filter_kw),
        'state': dumps(state),
355
    }
356
    return self.app.post('/requestComputerPartition', data=request_dict)
357

358
  def request(self, *args, **kw):
359 360 361 362
    """
    Simulate a request with above parameters
    Return response by server (a computer partition or an error)
    """
363 364
    rv = self._requestComputerPartition(*args, **kw)
    requested_at = time.time()
365
    self.assertEqual(rv._status_code, 200)
366
    xml = rv.data
Bryton Lacquement's avatar
Bryton Lacquement committed
367
    software_instance = loads(xml)
368 369

    computer_partition = slapos.slap.ComputerPartition(
370 371
        software_instance.slap_computer_id,
        software_instance.slap_computer_partition_id)
372

373
    computer_partition.__dict__.update(software_instance.__dict__)
374 375 376 377 378

    if not kw.get('shared'):
      self.assertLessEqual(
        float(computer_partition._parameter_dict['timestamp']), requested_at)

379 380
    return computer_partition

381
  def supply(self, url, computer_id=None, state='available'):
382 383 384 385 386 387 388
    if not computer_id:
      computer_id = self.computer_id
    request_dict = {'url':url, 'computer_id': computer_id, 'state':state}
    rv = self.app.post('/supplySupply',
                       data=request_dict)
    # XXX return a Software Release

389 390
  def setConnectionDict(self, partition_id,
                        connection_dict, slave_reference=None):
391
    self.app.post('/setComputerPartitionConnectionXml', data={
392 393
        'computer_id': self.computer_id,
        'computer_partition_id': partition_id,
Bryton Lacquement's avatar
Bryton Lacquement committed
394
        'connection_xml': dumps(connection_dict),
395
        'slave_reference': slave_reference})
396

397
  def getPartitionInformation(self, computer_partition_id):
398 399 400
    """
    Return computer information as stored in proxy for corresponding id
    """
401
    computer = self.getFullComputerInformation()
402 403 404 405
    for instance in computer._computer_partition_list:
      if instance._partition_id == computer_partition_id:
        return instance

406 407 408 409 410 411 412 413 414 415 416 417 418 419 420 421 422 423 424 425 426 427 428 429 430 431 432 433 434 435 436 437 438 439 440 441 442 443 444 445 446 447 448 449 450 451 452 453 454 455 456 457 458 459 460 461 462 463 464 465 466 467
  def getFullComputerInformation(self):
    return loads(self.app.get('/getFullComputerInformation?computer_id=%s' % self.computer_id).data)


class TestSoftwareInstallation(MasterMixin, unittest.TestCase):
  def setUp(self):
    super(TestSoftwareInstallation, self).setUp()
    self.software_release_url = self.id()

  def assertSoftwareState(self, state):
    # Check that the software was requested in `state`
    sr, = self.getFullComputerInformation()._software_release_list
    self.assertEqual(sr.getState(), state)

  def test_installation_success(self):
    self.supply(self.software_release_url)
    self.assertSoftwareState('available')

    self.app.post('/buildingSoftwareRelease', data={
      'url': self.software_release_url,
      'computer_id': self.computer_id
    })
    # there's no intermediate "building" state, because state is
    # the "requested state".
    self.assertSoftwareState('available')

    self.app.post('/availableSoftwareRelease', data={
      'url': self.software_release_url,
      'computer_id': self.computer_id
    })
    self.assertSoftwareState('available')

  def test_installation_failed(self):
    self.supply(self.software_release_url)
    self.assertSoftwareState('available')

    self.app.post('/buildingSoftwareRelease', data={
      'url': self.software_release_url,
      'computer_id': self.computer_id
    })
    self.assertSoftwareState('available')

    self.app.post('/softwareReleaseError', data={
      'url': self.software_release_url,
      'computer_id': self.computer_id
    })
    self.assertSoftwareState('available')

  def test_destroyed(self):
    self.supply(self.software_release_url)
    self.assertSoftwareState('available')

    self.supply(self.software_release_url, state="destroyed")
    self.assertSoftwareState('destroyed')

    self.app.post('/destroyedSoftwareRelease', data={
      'url': self.software_release_url,
      'computer_id': self.computer_id
    })
    # this really remove the software from DB
    self.assertEqual([], self.getFullComputerInformation()._software_release_list)

468

469
class TestRequest(MasterMixin):
470 471 472
  """
  Set of tests for requests
  """
473 474 475 476 477 478

  def test_request_consistent_parameters(self):
    """
    Check that all different parameters related to requests (like instance_guid, state) are set and consistent
    """
    self.add_free_partition(1)
479
    partition = self.request('http://sr//', None, 'MyFirstInstance', 'slappart0')
480
    self.assertEqual(partition.getState(), 'started')
481
    self.assertEqual(partition.getInstanceGuid(), 'computer-slappart0')
482

483
  def test_two_request_one_partition_free(self):
484
    """
Marco Mariani's avatar
Marco Mariani committed
485 486
    Since slapproxy does not implement scope, providing two partition_id
    values will still succeed, even if only one partition is available.
487
    """
488
    self.add_free_partition(1)
489
    self.assertIsInstance(self.request('http://sr//', None,
490
                                       'MyFirstInstance', 'slappart2'),
491
                          slapos.slap.ComputerPartition)
Marco Mariani's avatar
Marco Mariani committed
492
    self.assertIsInstance(self.request('http://sr//', None,
493
                                       'MyFirstInstance', 'slappart3'),
Marco Mariani's avatar
Marco Mariani committed
494
                          slapos.slap.ComputerPartition)
495

496
  def test_two_request_two_partition_free(self):
497 498 499 500
    """
    If two requests are made with two available partition
    both will succeed
    """
501
    self.add_free_partition(2)
502
    self.assertIsInstance(self.request('http://sr//', None,
503
                                       'MyFirstInstance', 'slappart2'),
504
                          slapos.slap.ComputerPartition)
505
    self.assertIsInstance(self.request('http://sr//', None,
506
                                       'MyFirstInstance', 'slappart3'),
507 508
                          slapos.slap.ComputerPartition)

509
  def test_two_same_request_from_one_partition(self):
510 511 512
    """
    Request will return same partition for two equal requests
    """
513
    self.add_free_partition(2)
514 515 516 517 518 519 520 521
    def do_request():
      return self.request('http://sr//', None, 'MyFirstInstance', 'slappart2')
    requested_at = time.time()
    partition = do_request()
    self.assertLessEqual(float(str(requested_at)),
      float(partition._parameter_dict['timestamp']))
    time.sleep(.1) # check timestamp does not change for an identical request
    self.assertEqual(partition.__dict__, do_request().__dict__)
522

523 524 525 526 527 528 529 530 531 532 533 534 535 536 537 538 539 540 541 542 543 544 545 546 547 548 549 550 551 552
  def test_instance_bang(self):
    """
    Check that instance bang update the timestamps of all partitions in the
    instance.
    """
    self.add_free_partition(3)
    requested_at = time.time()
    parent = self.request('http://sr//', None, 'MyFirstInstance')
    child = self.request('http://sr//', None, 'MySubInstance',
                         parent._partition_id)
    other = self.request('http://sr//', None, 'AnotherInstance')
    for partition in parent, child, other:
      self.assertLessEqual(float(str(requested_at)),
        float(partition._parameter_dict['timestamp']))
    other_timestamp = other._parameter_dict['timestamp']
    def getTimestamp(partition):
      return self.getPartitionInformation(
        partition._partition_id)._parameter_dict['timestamp']
    for partition in parent, child:
      time.sleep(.1)
      bang_at = time.time()
      self.app.post('/softwareInstanceBang', data={
        'computer_id': self.computer_id,
        'computer_partition_id': partition._partition_id,
        'message': self.id()})
      timestamp = getTimestamp(parent)
      self.assertLessEqual(float(str(requested_at)), float(timestamp))
      self.assertEqual(getTimestamp(child), timestamp)
      self.assertEqual(getTimestamp(other), other_timestamp)

553 554 555 556 557
  def test_request_propagate_partition_state(self):
    """
    Request will return same partition for two equal requests
    """
    self.add_free_partition(2)
558 559 560 561 562 563 564 565 566 567 568 569 570 571 572 573
    def request_parent(**kw):
      return self.request('http://sr//', None, 'MyFirstInstance', **kw)
    def request_child():
      return self.request('http://sr//', None, 'MySubInstance', parent_id)

    parent = request_parent()
    parent_id = parent._partition_id
    child = request_child()
    self.assertEqual('started', parent.getState())
    self.assertEqual('started', child.getState())

    for state in 'stopped', 'started':
      parent = request_parent(state=state)
      child = request_child()
      self.assertEqual(state, parent.getState())
      self.assertEqual(state, child.getState())
574 575 576 577 578 579 580 581 582

  def test_request_parent_started_children_stopped(self):
    """
    Request will return same partition for two equal requests
    """
    self.add_free_partition(2)
    partition_parent = self.request('http://sr//', None, 'MyFirstInstance')
    parent_dict = partition_parent.__dict__
    partition_child = self.request('http://sr//', None, 'MySubInstance', parent_dict['_partition_id'])
583

584 585 586 587 588
    self.assertEqual(partition_parent.getState(), 'started')
    self.assertEqual(partition_child.getState(), 'started')

    partition_parent = self.request('http://sr//', None, 'MyFirstInstance')
    partition_child = self.request('http://sr//', None, 'MySubInstance', parent_dict['_partition_id'], state='stopped')
589

590 591 592
    self.assertEqual(partition_parent.getState(), 'started')
    self.assertEqual(partition_child.getState(), 'stopped')

593
  def test_two_requests_with_different_parameters_but_same_reference(self):
594
    """
595 596
    Request will return same partition for two different requests but will
    only update parameters
597 598 599 600
    """
    self.add_free_partition(2)
    wanted_domain1 = 'fou.org'
    wanted_domain2 = 'carzy.org'
601

602
    request1 = self.request('http://sr//', None, 'MyFirstInstance', 'slappart2',
603
                            partition_parameter_kw={'domain': wanted_domain1})
604 605
    requested_result1 = self.getPartitionInformation(request1._partition_id)
    time.sleep(.1) # so that timestamp changes
606
    request2 = self.request('http://sr//', 'Papa', 'MyFirstInstance', 'slappart2',
607
                            partition_parameter_kw={'domain': wanted_domain2})
608
    requested_result2 = self.getPartitionInformation(request2._partition_id)
609
    # Test we received same partition
610 611
    for key in '_partition_id', '_computer_id':
      self.assertEqual(getattr(request1, key), getattr(request2, key))
612
    # Test that only parameters changed
613
    for key in requested_result2.__dict__:
614 615 616 617 618 619
      if key == '_software_release_document':
        self.assertEqual(getattr(requested_result2, key).__dict__,
                         getattr(requested_result1, key).__dict__)
      elif key != '_parameter_dict':
        self.assertEqual(getattr(requested_result2, key),
                         getattr(requested_result1, key))
620 621 622 623 624
    #Test parameters where set correctly
    self.assertEqual(wanted_domain1,
                     requested_result1._parameter_dict['domain'])
    self.assertEqual(wanted_domain2,
                     requested_result2._parameter_dict['domain'])
625

626 627 628 629 630 631
    t1 = request1._parameter_dict['timestamp']
    t2 = request2._parameter_dict['timestamp']
    self.assertLess(float(t1), float(t2))
    self.assertEqual(t1, requested_result1._parameter_dict['timestamp'])
    self.assertEqual(t2, requested_result2._parameter_dict['timestamp'])

632 633 634 635 636 637 638 639 640 641 642 643 644 645 646 647 648 649 650 651 652 653 654 655 656 657 658 659 660 661 662 663 664 665 666 667 668 669 670
  def test_two_requests_with_different_parameters_and_sr_url_but_same_reference(self):
    """
    Request will return same partition for two different requests but will
    only update parameters
    """
    self.add_free_partition(2)
    wanted_domain1 = 'fou.org'
    wanted_domain2 = 'carzy.org'

    request1 = self.request('http://sr//', None, 'MyFirstInstance', 'slappart2',
                            partition_parameter_kw={'domain': wanted_domain1})
    request1_dict = request1.__dict__
    requested_result1 = self.getPartitionInformation(
        request1_dict['_partition_id'])
    request2 = self.request('http://sr1//', 'Papa', 'MyFirstInstance', 'slappart2',
                            partition_parameter_kw={'domain': wanted_domain2})
    request2_dict = request2.__dict__
    requested_result2 = self.getPartitionInformation(
        request2_dict['_partition_id'])
    # Test we received same partition
    for key in ['_partition_id', '_computer_id']:
      self.assertEqual(request1_dict[key], request2_dict[key])
    # Test that parameters and software_release url changed
    for key in requested_result2.__dict__:
      if key not in ['_parameter_dict',
                     '_software_release_document']:
        self.assertEqual(requested_result2.__dict__[key],
                         requested_result1.__dict__[key])
      elif key in ['_software_release_document']:
        # software_release will be updated
        self.assertEqual(requested_result2.__dict__[key].__dict__['_software_release'],
                         'http://sr1//')
        self.assertEqual(requested_result1.__dict__[key].__dict__['_software_release'],
                         'http://sr//')
    #Test parameters where set correctly
    self.assertEqual(wanted_domain1,
                     requested_result1._parameter_dict['domain'])
    self.assertEqual(wanted_domain2,
                     requested_result2._parameter_dict['domain'])
671

672
  def test_two_different_request_from_two_partition(self):
673
    """
Marco Mariani's avatar
Marco Mariani committed
674 675
    Since slapproxy does not implement scope, two request with
    different partition_id will still return the same partition.
676
    """
677
    self.add_free_partition(2)
Marco Mariani's avatar
Marco Mariani committed
678
    self.assertEqual(
679 680
        self.request('http://sr//', None, 'MyFirstInstance', 'slappart2').__dict__,
        self.request('http://sr//', None, 'MyFirstInstance', 'slappart3').__dict__)
681

682
  def test_two_different_request_from_one_partition(self):
683 684 685 686
    """
    Two different request from same partition
    will return two different partitions
    """
687 688
    self.add_free_partition(2)
    self.assertNotEqual(
689
        self.request('http://sr//', None, 'MyFirstInstance', 'slappart2').__dict__,
690
        self.request('http://sr//', None, 'frontend', 'slappart2').__dict__)
691

692 693 694 695 696 697 698 699 700
  def test_request_with_nonascii_parameters(self):
    """
    Verify that request with non-ascii parameters is correctly accepted
    """
    self.add_free_partition(1)
    request = self.request('http://sr//', None, 'myinstance', 'slappart0',
                           partition_parameter_kw={'text': u'Привет Мир!'})
    self.assertIsInstance(request, slapos.slap.ComputerPartition)

701 702 703 704 705 706 707 708 709 710 711 712 713 714 715 716 717 718 719 720 721 722 723 724 725
  def test_request_with_int(self):
    """
    Verify that request with int parameters is correctly accepted
    """
    self.add_free_partition(1)
    request = self.request('http://sr//', None, 'myinstance', 'slappart0',
                           partition_parameter_kw={'int': 1})
    self.assertIsInstance(request, slapos.slap.ComputerPartition)

  def test_request_set_connection_parameters_with_int(self):
    """
    Verify that request int works in connection parameters
    """
    self.add_free_partition(1)
    partition_id = self.request('http://sr//', None, 'myinstance', 'slappart0')._partition_id
    # Set connection parameter
    partition = self.getPartitionInformation(partition_id)

    self.setConnectionDict(partition_id=partition_id,
                           connection_dict={'foo': 1})

    # Get updated information for the partition
    partition_new = self.request('http://sr//', None, 'myinstance', 'slappart0')
    self.assertEqual(partition_new.getConnectionParameter('foo'), '1')

726 727 728 729 730 731 732 733 734 735 736 737 738 739 740 741
  def test_request_frontend(self):
    # slapproxy tells client to bypass "simple" frontends by just using the URL.
    request = self.request(
        'http://git.erp5.org/gitweb/slapos.git/blob_plain/HEAD:/software/apache-frontend/software.cfg',
        None,
        self.id(),
        'slappart0',
        shared=True,
        partition_parameter_kw={'url': 'https://[::1]:123/', })
    self.assertEqual(
        'https://[::1]:123/',
        request.getConnectionParameterDict()['secure_access'])
    self.assertEqual(
        '[::1]:123',
        request.getConnectionParameterDict()['domain'])

742 743 744 745 746 747 748 749 750 751 752 753 754 755 756 757 758 759 760 761 762 763
  def test_request_kvm_frontend(self):
    # slapproxy tells client to bypass kvm vnc frontends by building an URL using the backend.
    request = self.request(
        'http://git.erp5.org/gitweb/slapos.git/blob_plain/refs/tags/slapos-0.92:/software/kvm/software.cfg',
        'frontend',
        self.id(),
        'slappart0',
        shared=True,
        partition_parameter_kw={'host': '::1', 'port': '123'})
    self.assertEqual(
        'https://[::1]:123/',
        request.getConnectionParameterDict()['url'])
    self.assertEqual(
        '[::1]',
        request.getConnectionParameterDict()['domainname'])
    self.assertEqual(
        '123',
        request.getConnectionParameterDict()['port'])
    self.assertEqual(
        '/',
        request.getConnectionParameterDict()['path'])

764

765
class TestSlaveRequest(MasterMixin):
766 767 768
  """
  Test requests related to slave instances.
  """
769
  def test_slave_request_no_corresponding_partition(self):
770 771 772
    """
    Slave instance request will fail if no corresponding are found
    """
773
    self.add_free_partition(2)
774 775
    rv = self._requestComputerPartition('http://sr//', None, 'MyFirstInstance', 'slappart2', shared=True)
    self.assertEqual(rv._status_code, 404)
776

777
  def test_slave_request_set_parameters(self):
778 779 780 781 782 783 784 785 786 787
    """
    Parameters sent in slave request must be put in slave master
    slave instance list.
    1. We request a slave instance we defined parameters
    2. We check parameters are in the dictionnary defining slave in
        slave master slave_instance_list
    """
    self.add_free_partition(6)
    # Provide partition
    master_partition_id = self.request('http://sr//', None,
788
                                       'MyFirstInstance', 'slappart4')._partition_id
789 790
    # First request of slave instance
    wanted_domain = 'fou.org'
791
    self.request('http://sr//', None, 'MyFirstInstance', 'slappart2', shared=True,
792
                 partition_parameter_kw={'domain': wanted_domain})
793 794 795 796
    # Get updated information for master partition
    master_partition = self.getPartitionInformation(master_partition_id)

    our_slave = master_partition._parameter_dict['slave_instance_list'][0]
797
    self.assertEqual(our_slave.get('domain'), wanted_domain)
798

799 800 801 802 803 804 805 806 807 808 809
  def test_master_instance_with_no_slave(self):
    """
    Test that a master instance with no requested slave
    has an empty slave_instance_list parameter.
    """
    self.add_free_partition(6)
    # Provide partition
    master_partition_id = self.request('http://sr//', None, 'MyMasterInstance', 'slappart4')._partition_id
    master_partition = self.getPartitionInformation(master_partition_id)
    self.assertEqual(len(master_partition._parameter_dict['slave_instance_list']), 0)

810
  def test_slave_request_set_parameters_are_updated(self):
811 812 813 814 815 816 817 818 819 820 821 822 823
    """
    Parameters sent in slave request must be put in slave master
    slave instance list and updated when they change.
    1. We request a slave instance we defined parameters
    2. We check parameters are in the dictionnary defining slave in
        slave master slave_instance_list
    3. We request same slave instance with changed parameters
    4. We check parameters are in the dictionnary defining slave in
        slave master slave_instance_list have changed
    """
    self.add_free_partition(6)
    # Provide partition
    master_partition_id = self.request('http://sr//', None,
824
                                       'MyFirstInstance', 'slappart4')._partition_id
825 826
    # First request of slave instance
    wanted_domain_1 = 'crazy.org'
827
    self.request('http://sr//', None, 'MyFirstInstance', 'slappart2', shared=True,
828
                 partition_parameter_kw={'domain': wanted_domain_1})
829 830 831
    # Get updated information for master partition
    master_partition = self.getPartitionInformation(master_partition_id)
    our_slave = master_partition._parameter_dict['slave_instance_list'][0]
832
    self.assertEqual(our_slave.get('domain'), wanted_domain_1)
833 834 835

    # Second request of slave instance
    wanted_domain_2 = 'maluco.org'
836
    self.request('http://sr//', None, 'MyFirstInstance', 'slappart2', shared=True,
837
                 partition_parameter_kw={'domain': wanted_domain_2})
838 839 840 841
    # Get updated information for master partition
    master_partition = self.getPartitionInformation(master_partition_id)

    our_slave = master_partition._parameter_dict['slave_instance_list'][0]
842 843
    self.assertNotEqual(our_slave.get('domain'), wanted_domain_1)
    self.assertEqual(our_slave.get('domain'), wanted_domain_2)
844

845 846 847 848 849 850 851 852 853 854 855 856 857 858
  def test_slave_request_set_connection_parameters(self):
    """
    Parameters set in slave instance by master instance must be put in slave instance connection parameters.
    1. We request a slave instance
    2. We set connection parameters for this slave instance
    2. We check parameter is present when we do request() for the slave.
    """
    self.add_free_partition(6)
    # Provide partition
    master_partition_id = self.request('http://sr//', None, 'MyMasterInstance', 'slappart4')._partition_id
    # First request of slave instance
    self.request('http://sr//', None, 'MySlaveInstance', 'slappart2', shared=True)
    # Set connection parameter
    master_partition = self.getPartitionInformation(master_partition_id)
859
    # XXX change slave reference to be compatible with multiple nodes
860 861 862
    self.setConnectionDict(partition_id=master_partition._partition_id,
                           connection_dict={'foo': 'bar'},
                           slave_reference=master_partition._parameter_dict['slave_instance_list'][0]['slave_reference'])
863

864 865 866 867
    # Get updated information for slave partition
    slave_partition = self.request('http://sr//', None, 'MySlaveInstance', 'slappart2', shared=True)
    self.assertEqual(slave_partition.getConnectionParameter('foo'), 'bar')

868
  def test_slave_request_one_corresponding_partition(self):
869 870 871
    """
    Successfull request slave instance follow these steps:
    1. Provide one corresponding partition
872
    2. Ask for Slave instance. But no connection parameters
873 874
       But slave is added to Master Instance slave list
    3. Master Instance get updated information (including slave list)
875
    4. Master instance post information about slave connection parameters
876
    5. Ask for slave instance is successfull and return a computer instance
877
        with connection information
878
    """
879
    self.add_free_partition(6)
880 881
    # Provide partition
    master_partition_id = self.request('http://sr//', None,
882
                                       'MyFirstInstance', 'slappart4')._partition_id
883
    # First request of slave instance
884
    name = 'MyFirstInstance'
885
    requester = 'slappart2'
886
    our_slave = self.request('http://sr//', None, name, requester, shared=True)
887
    self.assertIsInstance(our_slave, slapos.slap.ComputerPartition)
888
    self.assertEqual(our_slave._connection_dict, {})
889
    # Get updated information for master partition
890 891
    master_partition = self.getPartitionInformation(master_partition_id)
    slave_for_master = master_partition._parameter_dict['slave_instance_list'][0]
892
    # Send information about slave
893
    slave_address = {'url': '%s.master.com'}
894 895 896
    self.setConnectionDict(partition_id=master_partition._partition_id,
                           connection_dict=slave_address,
                           slave_reference=slave_for_master['slave_reference'])
897
    # Successfull slave request with connection parameters
898 899
    our_slave = self.request('http://sr//', None,
                             name, requester, shared=True)
900 901
    self.assertIsInstance(our_slave, slapos.slap.ComputerPartition)
    self.assertEqual(slave_address, our_slave._connection_dict)
902

903 904 905 906 907 908 909 910 911 912 913 914
  def test_slave_request_instance_guid(self):
    """
    Test that instance_guid support behaves correctly.
    Warning: proxy doesn't gives unique id of instance, but gives instead unique id
    of partition.
    """
    self.add_free_partition(1)
    partition = self.request('http://sr//', None, 'MyInstance', 'slappart1')
    slave = self.request('http://sr//', None, 'MySlaveInstance', 'slappart1',
         shared=True, filter_kw=dict(instance_guid=partition._instance_guid))
    self.assertEqual(slave._partition_id, partition._partition_id)

915

916 917 918 919 920 921 922 923 924 925 926 927 928 929 930
class TestMultiNodeSupport(MasterMixin):
  def test_multi_node_support_different_software_release_list(self):
    """
    Test that two different registered computers have their own
    Software Release list.
    """
    self.add_free_partition(6, computer_id='COMP-0')
    self.add_free_partition(6, computer_id='COMP-1')
    software_release_1_url = 'http://sr1'
    software_release_2_url = 'http://sr2'
    software_release_3_url = 'http://sr3'
    self.supply(software_release_1_url, 'COMP-0')
    self.supply(software_release_2_url, 'COMP-1')
    self.supply(software_release_3_url, 'COMP-0')
    self.supply(software_release_3_url, 'COMP-1')
931

932 933
    computer_default = loads(self.app.get('/getFullComputerInformation?computer_id=%s' % self.computer_id).data)
    computer_0 = loads(self.app.get('/getFullComputerInformation?computer_id=COMP-0').data)
934
    computer_1 = loads(self.app.get('/getFullComputerInformation?computer_id=COMP-1').data)
935 936 937 938 939 940 941 942 943 944 945 946 947 948 949 950 951 952 953 954 955 956 957 958 959 960 961 962 963 964 965 966 967 968 969 970 971 972 973 974 975 976 977 978 979 980 981 982 983 984 985 986 987 988
    self.assertEqual(len(computer_default._software_release_list), 0)
    self.assertEqual(len(computer_0._software_release_list), 2)
    self.assertEqual(len(computer_1._software_release_list), 2)

    self.assertEqual(
        computer_0._software_release_list[0]._software_release,
        software_release_1_url
    )
    self.assertEqual(
        computer_0._software_release_list[0]._computer_guid,
        'COMP-0'
    )

    self.assertEqual(
        computer_0._software_release_list[1]._software_release,
        software_release_3_url
    )
    self.assertEqual(
        computer_0._software_release_list[1]._computer_guid,
        'COMP-0'
    )

    self.assertEqual(
        computer_1._software_release_list[0]._software_release,
        software_release_2_url
    )
    self.assertEqual(
        computer_1._software_release_list[0]._computer_guid,
        'COMP-1'
    )

    self.assertEqual(
        computer_1._software_release_list[1]._software_release,
        software_release_3_url
    )
    self.assertEqual(
        computer_1._software_release_list[1]._computer_guid,
        'COMP-1'
    )

  def test_multi_node_support_remove_software_release(self):
    """
    Test that removing a software from a Computer doesn't
    affect other computer
    """
    software_release_url = 'http://sr'
    self.add_free_partition(6, computer_id='COMP-0')
    self.add_free_partition(6, computer_id='COMP-1')
    self.supply(software_release_url, 'COMP-0')
    self.supply(software_release_url, 'COMP-1')
    self.supply(software_release_url, 'COMP-0', state='destroyed')
    computer_0 = loads(self.app.get('/getFullComputerInformation?computer_id=COMP-0').data)
    computer_1 = loads(self.app.get('/getFullComputerInformation?computer_id=COMP-1').data)

989 990 991 992 993 994 995 996 997 998 999 1000 1001
    # at this point, software is requested to be destroyed on COMP-0
    self.assertEqual(
        computer_0._software_release_list[0].getURI(),
        software_release_url
    )
    self.assertEqual(
        computer_0._software_release_list[0].getComputerId(),
        'COMP-0'
    )
    self.assertEqual(
        computer_0._software_release_list[0].getState(),
        'destroyed'
    )
1002

1003
    # but is still requested for installation on COMP-1
1004
    self.assertEqual(
1005
        computer_1._software_release_list[0].getURI(),
1006 1007 1008
        software_release_url
    )
    self.assertEqual(
1009
        computer_1._software_release_list[0].getComputerId(),
1010 1011
        'COMP-1'
    )
1012 1013 1014 1015
    self.assertEqual(
        computer_1._software_release_list[0].getState(),
        'available'
    )
1016 1017 1018 1019 1020 1021 1022 1023 1024 1025 1026 1027 1028 1029 1030 1031 1032 1033 1034 1035 1036 1037 1038 1039 1040 1041 1042 1043 1044 1045 1046 1047 1048 1049 1050 1051 1052 1053 1054 1055 1056 1057 1058 1059 1060 1061 1062 1063 1064 1065 1066 1067 1068 1069 1070 1071 1072 1073 1074 1075 1076 1077 1078 1079 1080 1081 1082 1083 1084 1085 1086 1087 1088 1089 1090 1091 1092 1093 1094 1095 1096 1097 1098 1099 1100 1101 1102 1103 1104 1105 1106 1107 1108 1109 1110 1111 1112 1113 1114 1115 1116 1117 1118 1119 1120 1121 1122 1123 1124 1125 1126 1127 1128 1129 1130 1131 1132 1133 1134 1135 1136 1137 1138 1139 1140 1141 1142 1143 1144 1145 1146 1147 1148 1149 1150 1151 1152 1153 1154 1155 1156 1157 1158 1159 1160 1161 1162 1163 1164 1165 1166 1167 1168 1169 1170 1171 1172 1173 1174 1175

  def test_multi_node_support_instance_default_computer(self):
    """
    Test that instance request behaves correctly with default computer
    """
    software_release_url = 'http://sr'
    computer_0_id = 'COMP-0'
    computer_1_id = 'COMP-1'
    self.add_free_partition(6, computer_id=computer_0_id)
    self.add_free_partition(6, computer_id=computer_1_id)

    # Request without SLA -> goes to default computer only.
    # It should fail if we didn't registered partitions for default computer
    # (default computer is always registered)
    rv = self._requestComputerPartition('http://sr//', None, 'MyFirstInstance', 'slappart2')
    self.assertEqual(rv._status_code, 404)

    rv = self._requestComputerPartition('http://sr//', None, 'MyFirstInstance', 'slappart2',
                                        filter_kw={'computer_guid':self.computer_id})
    self.assertEqual(rv._status_code, 404)

    # Register default computer: deployment works
    self.add_free_partition(1)
    self.request('http://sr//', None, 'MyFirstInstance', 'slappart0')
    computer_default = loads(self.app.get(
        '/getFullComputerInformation?computer_id=%s' % self.computer_id).data)
    self.assertEqual(len(computer_default._software_release_list), 0)

    # No free space on default computer: request without SLA fails
    rv = self._requestComputerPartition('http://sr//', None, 'CanIHasPartition', 'slappart2',
                                        filter_kw={'computer_guid':self.computer_id})
    self.assertEqual(rv._status_code, 404)

  def test_multi_node_support_instance(self):
    """
    Test that instance request behaves correctly with several
    registered computers
    """
    software_release_url = 'http://sr'
    computer_0_id = 'COMP-0'
    computer_1_id = 'COMP-1'
    software_release_1 = 'http://sr//'
    software_release_2 = 'http://othersr//'

    self.add_free_partition(2, computer_id=computer_1_id)

    # Deploy to first non-default computer using SLA
    # It should fail since computer is not registered
    rv = self._requestComputerPartition(software_release_1, None, 'MyFirstInstance', 'slappart2', filter_kw={'computer_guid':computer_0_id})
    self.assertEqual(rv._status_code, 404)

    self.add_free_partition(2, computer_id=computer_0_id)

    # Deploy to first non-default computer using SLA
    partition = self.request(software_release_1, None, 'MyFirstInstance', 'slappart0', filter_kw={'computer_guid':computer_0_id})
    self.assertEqual(partition.getState(), 'started')
    self.assertEqual(partition._partition_id, 'slappart0')
    self.assertEqual(partition._computer_id, computer_0_id)
    # All other instances should be empty
    computer_0 = loads(self.app.get('/getFullComputerInformation?computer_id=COMP-0').data)
    computer_1 = loads(self.app.get('/getFullComputerInformation?computer_id=COMP-1').data)
    self.assertEqual(computer_0._computer_partition_list[0]._software_release_document._software_release, software_release_1)
    self.assertTrue(computer_0._computer_partition_list[1]._software_release_document == None)
    self.assertTrue(computer_1._computer_partition_list[0]._software_release_document == None)
    self.assertTrue(computer_1._computer_partition_list[1]._software_release_document == None)

    # Deploy to second non-default computer using SLA
    partition = self.request(software_release_2, None, 'MySecondInstance', 'slappart0', filter_kw={'computer_guid':computer_1_id})
    self.assertEqual(partition.getState(), 'started')
    self.assertEqual(partition._partition_id, 'slappart0')
    self.assertEqual(partition._computer_id, computer_1_id)
    # The two remaining instances should be free, and MyfirstInstance should still be there
    computer_0 = loads(self.app.get('/getFullComputerInformation?computer_id=COMP-0').data)
    computer_1 = loads(self.app.get('/getFullComputerInformation?computer_id=COMP-1').data)
    self.assertEqual(computer_0._computer_partition_list[0]._software_release_document._software_release, software_release_1)
    self.assertTrue(computer_0._computer_partition_list[1]._software_release_document == None)
    self.assertEqual(computer_1._computer_partition_list[0]._software_release_document._software_release, software_release_2)
    self.assertTrue(computer_1._computer_partition_list[1]._software_release_document == None)

  def test_multi_node_support_change_instance_state(self):
    """
    Test that destroying an instance (i.e change state) from a Computer doesn't
    affect other computer
    """
    software_release_url = 'http://sr'
    computer_0_id = 'COMP-0'
    computer_1_id = 'COMP-1'
    self.add_free_partition(6, computer_id=computer_0_id)
    self.add_free_partition(6, computer_id=computer_1_id)
    partition_first = self.request('http://sr//', None, 'MyFirstInstance', 'slappart0', filter_kw={'computer_guid':computer_0_id})
    partition_second = self.request('http://sr//', None, 'MySecondInstance', 'slappart0', filter_kw={'computer_guid':computer_1_id})

    partition_first = self.request('http://sr//', None, 'MyFirstInstance', 'slappart0', filter_kw={'computer_guid':computer_0_id}, state='stopped')

    computer_0 = loads(self.app.get('/getFullComputerInformation?computer_id=COMP-0').data)
    computer_1 = loads(self.app.get('/getFullComputerInformation?computer_id=COMP-1').data)
    self.assertEqual(computer_0._computer_partition_list[0].getState(), 'stopped')
    self.assertEqual(computer_0._computer_partition_list[1].getState(), 'destroyed')
    self.assertEqual(computer_1._computer_partition_list[0].getState(), 'started')
    self.assertEqual(computer_1._computer_partition_list[1].getState(), 'destroyed')

  def test_multi_node_support_same_reference(self):
    """
    Test that requesting an instance with same reference to two
    different nodes behaves like master: once an instance is assigned to a node,
    changing SLA will not change node.
    """
    software_release_url = 'http://sr'
    computer_0_id = 'COMP-0'
    computer_1_id = 'COMP-1'
    self.add_free_partition(2, computer_id=computer_0_id)
    self.add_free_partition(2, computer_id=computer_1_id)
    partition = self.request('http://sr//', None, 'MyFirstInstance', 'slappart0', filter_kw={'computer_guid':computer_0_id})
    partition = self.request('http://sr//', None, 'MyFirstInstance', 'slappart0', filter_kw={'computer_guid':computer_1_id})

    self.assertEqual(partition._computer_id, computer_0_id)

    computer_1 = loads(self.app.get('/getFullComputerInformation?computer_id=COMP-1').data)
    self.assertTrue(computer_1._computer_partition_list[0]._software_release_document == None)
    self.assertTrue(computer_1._computer_partition_list[1]._software_release_document == None)

  def test_multi_node_support_slave_instance(self):
    """
    Test that slave instances are correctly deployed if SLA is specified
    but deployed only on default computer if not specified (i.e not deployed
    if default computer doesn't have corresponding master instance).
    """
    computer_0_id = 'COMP-0'
    computer_1_id = 'COMP-1'
    self.add_free_partition(2, computer_id=computer_0_id)
    self.add_free_partition(2, computer_id=computer_1_id)
    self.add_free_partition(2)
    self.request('http://sr2//', None, 'MyFirstInstance', 'slappart0', filter_kw={'computer_guid':computer_0_id})
    self.request('http://sr//', None, 'MyOtherInstance', 'slappart0', filter_kw={'computer_guid':computer_1_id})

    # Request slave without SLA: will fail
    rv = self._requestComputerPartition('http://sr//', None, 'MySlaveInstance', 'slappart2', shared=True)
    self.assertEqual(rv._status_code, 404)

    # Request slave with SLA on incorrect computer: will fail
    rv = self._requestComputerPartition('http://sr//', None, 'MySlaveInstance', 'slappart2', shared=True, filter_kw={'computer_guid':computer_0_id})
    self.assertEqual(rv._status_code, 404)

    # Request computer on correct computer: will succeed
    partition = self.request('http://sr//', None, 'MySlaveInstance', 'slappart2', shared=True, filter_kw={'computer_guid':computer_1_id})
    self.assertEqual(partition._computer_id, computer_1_id)

  def test_multi_node_support_instance_guid(self):
    """
    Test that instance_guid support behaves correctly with multiple nodes.
    Warning: proxy doesn't gives unique id of instance, but gives instead unique id
    of partition.
    """
    computer_0_id = 'COMP-0'
    computer_1_id = 'COMP-1'
    self.add_free_partition(2, computer_id=computer_0_id)
    self.add_free_partition(2, computer_id=computer_1_id)
    self.add_free_partition(2)
    partition_computer_0 = self.request('http://sr2//', None, 'MyFirstInstance', 'slappart0', filter_kw={'computer_guid':computer_0_id})
    partition_computer_1 = self.request('http://sr//', None, 'MyOtherInstance', 'slappart0', filter_kw={'computer_guid':computer_1_id})
1176
    partition_computer_default = self.request('http://sr//', None, 'MyThirdInstance', 'slappart0')
1177 1178 1179 1180 1181 1182 1183 1184 1185 1186

    self.assertEqual(partition_computer_0.getInstanceGuid(), 'COMP-0-slappart0')
    self.assertEqual(partition_computer_1.getInstanceGuid(), 'COMP-1-slappart0')
    self.assertEqual(partition_computer_default.getInstanceGuid(), 'computer-slappart0')

  def test_multi_node_support_getComputerInformation(self):
    """
    Test that computer information will not be given if computer is not registered.
    Test that it still should work for the 'default' computer specified in slapos config
    even if not yet registered.
1187
    Test that computer information is given if computer is registered.
1188 1189 1190 1191 1192 1193 1194 1195 1196 1197 1198 1199 1200 1201 1202 1203
    """
    new_computer_id = '%s42' % self.computer_id
    with self.assertRaises(slapos.slap.NotFoundError):
      self.app.get('/getComputerInformation?computer_id=%s42' % new_computer_id)

    try:
      self.app.get('/getComputerInformation?computer_id=%s' % self.computer_id)
    except slapos.slap.NotFoundError:
      self.fail('Could not fetch informations for default computer.')

    self.add_free_partition(1, computer_id=new_computer_id)
    try:
      self.app.get('/getComputerInformation?computer_id=%s' % new_computer_id)
    except slapos.slap.NotFoundError:
      self.fail('Could not fetch informations for registered computer.')

1204

1205 1206 1207 1208 1209 1210 1211 1212
class TestMultiMasterSupport(MasterMixin):
  """
  Test multimaster support in slapproxy.
  """
  external_software_release = 'http://mywebsite.me/exteral_software_release.cfg'
  software_release_not_in_list = 'http://mywebsite.me/exteral_software_release_not_listed.cfg'

  def setUp(self):
1213
    self.addCleanup(self.stopExternalProxy)
1214
    self.external_proxy_host = os.environ.get('LOCAL_IPV4', '127.0.0.1')
1215 1216 1217
    self.external_proxy_port = 8281
    self.external_master_url = 'http://%s:%s' % (self.external_proxy_host, self.external_proxy_port)
    self.external_computer_id = 'external_computer'
1218 1219
    self.external_proxy_slap = slapos.slap.slap()
    self.external_proxy_slap.initializeConnection(self.external_master_url)
1220 1221 1222

    super(TestMultiMasterSupport, self).setUp()

1223
    self.db = sqlite_connect(self.proxy_db)
1224 1225 1226 1227 1228 1229 1230 1231 1232
    self.external_slapproxy_configuration_file_location = os.path.join(
        self._tempdir, 'external_slapos.cfg')
    self.createExternalProxyConfigurationFile()
    self.startExternalProxy()

  def tearDown(self):
    super(TestMultiMasterSupport, self).tearDown()

  def createExternalProxyConfigurationFile(self):
Bryton Lacquement's avatar
Bryton Lacquement committed
1233 1234
    with open(self.external_slapproxy_configuration_file_location, 'w') as f:
      f.write("""[slapos]
1235 1236
computer_id = %(external_computer_id)s
[slapproxy]
1237
host = %(host)s
1238 1239 1240 1241
port = %(port)s
database_uri = %(tempdir)s/lib/external_proxy.db
""" % {
    'tempdir': self._tempdir,
1242
    'host': self.external_proxy_host,
1243 1244 1245 1246 1247 1248 1249 1250
    'port': self.external_proxy_port,
    'external_computer_id': self.external_computer_id
    })

  def startExternalProxy(self):
    """
    Start external slapproxy
    """
1251
    logging.getLogger().info('Starting external proxy, listening to %s:%s' % (self.external_proxy_host, self.external_proxy_port))
1252 1253
    # XXX This uses a hack to run current code of slapos.core
    import slapos
1254 1255
    self.external_proxy_process = subprocess.Popen(
        [
1256
            sys.executable, '%s/../cli/entry.py' % os.path.dirname(slapos.tests.__file__),
1257 1258
            'proxy', 'start', '--cfg', self.external_slapproxy_configuration_file_location
        ],
1259 1260
        stdout=subprocess.DEVNULL,
        stderr=subprocess.DEVNULL,
1261 1262
        env={"PYTHONPATH": ':'.join(sys.path)}
    )
1263
    # Wait a bit for proxy to be started
1264 1265 1266 1267 1268 1269
    attempts = 0
    while (attempts < 20):
      try:
        self.external_proxy_slap._connection_helper.GET('/')
      except slapos.slap.NotFoundError:
        break
Bryton Lacquement's avatar
Bryton Lacquement committed
1270
      except (slapos.slap.ConnectionError, socket.error):
1271
        attempts = attempts + 1
1272
        time.sleep(0.1 * attempts)
1273 1274
    else:
      self.fail('Could not start external proxy.')
1275

1276 1277
  def stopExternalProxy(self):
    self.external_proxy_process.kill()
1278 1279 1280 1281 1282 1283

  def createSlapOSConfigurationFile(self):
    """
    Overwrite default slapos configuration file to enable specific multimaster
    behaviours.
    """
Bryton Lacquement's avatar
Bryton Lacquement committed
1284
    configuration = bytes2str(pkg_resources.resource_string(
1285
        'slapos.tests', os.path.join('test_slapproxy', 'slapos_multimaster.cfg.in')
Bryton Lacquement's avatar
Bryton Lacquement committed
1286
    )) % {
1287 1288 1289 1290
        'tempdir': self._tempdir, 'proxyaddr': self.proxyaddr,
        'external_proxy_host': self.external_proxy_host,
        'external_proxy_port': self.external_proxy_port
    }
1291 1292
    with open(self.slapos_cfg, 'w') as f:
      f.write(configuration)
1293 1294 1295 1296 1297 1298 1299 1300 1301 1302

  def external_proxy_add_free_partition(self, partition_amount, computer_id=None):
    """
    Will simulate a slapformat first run
    and create "partition_amount" partitions
    """
    if not computer_id:
      computer_id = self.external_computer_id
    computer_dict = {
        'reference': computer_id,
1303 1304
        'address': '12.34.56.78',
        'netmask': '255.255.255.255',
1305 1306 1307 1308 1309 1310 1311 1312 1313 1314 1315 1316 1317 1318 1319
        'partition_list': [],
    }
    for i in range(partition_amount):
      partition_example = {
          'reference': 'slappart%s' % i,
          'address_list': [
              {'addr': '1.2.3.4', 'netmask': '255.255.255.255'},
              {'addr': '4.3.2.1', 'netmask': '255.255.255.255'}
           ],
           'tap': {'name': 'tap0'},
      }
      computer_dict['partition_list'].append(partition_example)

    request_dict = {
        'computer_id': self.computer_id,
Bryton Lacquement's avatar
Bryton Lacquement committed
1320
        'xml': dumps(computer_dict),
1321 1322
    }
    self.external_proxy_slap._connection_helper.POST('/loadComputerConfigurationFromXML',
1323
                                                     data=request_dict)
1324 1325 1326 1327 1328 1329 1330 1331 1332 1333 1334 1335 1336 1337 1338 1339 1340 1341 1342 1343 1344 1345 1346 1347 1348 1349 1350 1351

  def _checkInstanceIsFowarded(self, name, partition_parameter_kw, software_release):
    """
    Test there is no instance on local proxy.
    Test there is instance on external proxy.
    Test there is instance reference in external table of databse of local proxy.
    """
    # Test it has been correctly added to local database
    forwarded_instance_list = slapos.proxy.views.execute_db('forwarded_partition_request', 'SELECT * from %s', db=self.db)
    self.assertEqual(len(forwarded_instance_list), 1)
    forwarded_instance = forwarded_instance_list[0]
    self.assertEqual(forwarded_instance['partition_reference'], name)
    self.assertEqual(forwarded_instance['master_url'], self.external_master_url)

    # Test there is nothing allocated locally
    computer = loads(self.app.get(
        '/getFullComputerInformation?computer_id=%s' % self.computer_id
    ).data)
    self.assertEqual(
        computer._computer_partition_list[0]._software_release_document,
        None
    )

    # Test there is an instance allocated in external master
    external_slap = slapos.slap.slap()
    external_slap.initializeConnection(self.external_master_url)
    external_computer = external_slap.registerComputer(self.external_computer_id)
    external_partition = external_computer.getComputerPartitionList()[0]
Bryton Lacquement's avatar
Bryton Lacquement committed
1352
    for k, v in six.iteritems(partition_parameter_kw):
1353 1354 1355 1356 1357 1358 1359 1360 1361 1362 1363 1364 1365 1366 1367 1368 1369 1370 1371 1372 1373 1374 1375 1376
      self.assertEqual(
          external_partition.getInstanceParameter(k),
          v
      )
    self.assertEqual(
        external_partition._software_release_document._software_release,
        software_release
    )

  def _checkInstanceIsAllocatedLocally(self, name, partition_parameter_kw, software_release):
    """
    Test there is one instance on local proxy.
    Test there NO is instance reference in external table of databse of local proxy.
    Test there is not instance on external proxy.
    """
    # Test it has NOT been added to local database
    forwarded_instance_list = slapos.proxy.views.execute_db('forwarded_partition_request', 'SELECT * from %s', db=self.db)
    self.assertEqual(len(forwarded_instance_list), 0)

    # Test there is an instance allocated locally
    computer = loads(self.app.get(
        '/getFullComputerInformation?computer_id=%s' % self.computer_id
    ).data)
    partition = computer._computer_partition_list[0]
Bryton Lacquement's avatar
Bryton Lacquement committed
1377
    for k, v in six.iteritems(partition_parameter_kw):
1378 1379 1380 1381 1382 1383 1384 1385 1386 1387 1388 1389 1390 1391 1392 1393 1394 1395 1396 1397 1398 1399 1400 1401 1402 1403 1404 1405 1406 1407 1408 1409 1410 1411 1412 1413 1414 1415 1416 1417 1418 1419 1420 1421 1422 1423 1424 1425 1426 1427 1428 1429 1430 1431 1432 1433 1434 1435 1436 1437 1438 1439 1440 1441 1442 1443 1444 1445 1446 1447 1448 1449 1450 1451 1452 1453 1454 1455 1456 1457 1458 1459 1460 1461 1462 1463 1464 1465 1466 1467 1468 1469 1470 1471 1472 1473 1474 1475 1476 1477 1478 1479 1480 1481
      self.assertEqual(
          partition.getInstanceParameter(k),
          v
      )
    self.assertEqual(
        partition._software_release_document._software_release,
        software_release
    )

    # Test there is NOT instance allocated in external master
    external_slap = slapos.slap.slap()
    external_slap.initializeConnection(self.external_master_url)
    external_computer = external_slap.registerComputer(self.external_computer_id)
    external_partition = external_computer.getComputerPartitionList()[0]
    self.assertEqual(
        external_partition._software_release_document,
        None
    )

  def testForwardToMasterInList(self):
    """
    Test that explicitely asking a master_url in SLA causes
    proxy to forward request to this master.
    """
    dummy_parameter_dict = {'foo': 'bar'}
    instance_reference = 'MyFirstInstance'
    self.add_free_partition(1)
    self.external_proxy_add_free_partition(1)

    filter_kw = {'master_url': self.external_master_url}
    partition = self.request(self.software_release_not_in_list, None, instance_reference, 'slappart0',
                             filter_kw=filter_kw, partition_parameter_kw=dummy_parameter_dict)

    self._checkInstanceIsFowarded(instance_reference, dummy_parameter_dict, self.software_release_not_in_list)
    self.assertEqual(
        partition._master_url,
        self.external_master_url
    )

  def testForwardToMasterNotInList(self):
    """
    Test that explicitely asking a master_url in SLA causes
    proxy to refuse to forward if this master_url is not whitelisted
    """
    self.add_free_partition(1)
    self.external_proxy_add_free_partition(1)

    filter_kw = {'master_url': self.external_master_url + 'bad'}
    rv = self._requestComputerPartition(self.software_release_not_in_list, None, 'MyFirstInstance', 'slappart0', filter_kw=filter_kw)
    self.assertEqual(rv._status_code, 404)

  def testForwardRequest_SoftwareReleaseList(self):
    """
    Test that instance request is automatically forwarded
    if its Software Release matches list.
    """
    dummy_parameter_dict = {'foo': 'bar'}
    instance_reference = 'MyFirstInstance'
    self.add_free_partition(1)
    self.external_proxy_add_free_partition(1)

    partition = self.request(self.external_software_release, None, instance_reference, 'slappart0',
                             partition_parameter_kw=dummy_parameter_dict)

    self._checkInstanceIsFowarded(instance_reference, dummy_parameter_dict, self.external_software_release)

  def testRequestToCurrentMaster(self):
    """
    Explicitely ask deployment of an instance to current master
    """
    self.add_free_partition(1)
    self.external_proxy_add_free_partition(1)
    instance_reference = 'MyFirstInstance'

    dummy_parameter_dict = {'foo': 'bar'}

    filter_kw = {'master_url': self.proxyaddr}
    self.request(self.software_release_not_in_list, None, instance_reference, 'slappart0',
                 filter_kw=filter_kw, partition_parameter_kw=dummy_parameter_dict)
    self._checkInstanceIsAllocatedLocally(instance_reference, dummy_parameter_dict, self.software_release_not_in_list)

  def testRequestExplicitelyOnExternalMasterThenRequestAgain(self):
    """
    Request an instance that will get forwarded to another an instance.
    Test that subsequent request without SLA doesn't forward
    """
    dummy_parameter_dict = {'foo': 'bar'}

    self.testForwardToMasterInList()
    partition = self.request(self.software_release_not_in_list, None, 'MyFirstInstance', 'slappart0', partition_parameter_kw=dummy_parameter_dict)
    self.assertEqual(
        getattr(partition, '_master_url', None),
        None
    )

    # Test it has not been removed from local database (we keep track)
    forwarded_instance_list = slapos.proxy.views.execute_db('forwarded_partition_request', 'SELECT * from %s', db=self.db)
    self.assertEqual(len(forwarded_instance_list), 1)

    # Test there is an instance allocated locally
    computer = loads(self.app.get(
        '/getFullComputerInformation?computer_id=%s' % self.computer_id
    ).data)
    partition = computer._computer_partition_list[0]
Bryton Lacquement's avatar
Bryton Lacquement committed
1482
    for k, v in six.iteritems(dummy_parameter_dict):
1483 1484 1485 1486 1487 1488 1489 1490 1491
      self.assertEqual(
          partition.getInstanceParameter(k),
          v
      )
    self.assertEqual(
        partition._software_release_document._software_release,
        self.software_release_not_in_list
    )

1492

1493 1494

class _MigrationTestCase(TestInformation, TestRequest, TestSlaveRequest, TestMultiNodeSupport):
1495 1496 1497
  """
  Test that old database version are automatically migrated without failure
  """
1498 1499
  dump_filename = NotImplemented
  initial_table_list = NotImplemented
1500
  current_version = '14'
1501

1502
  def setUp(self):
1503
    TestInformation.setUp(self)
Bryton Lacquement's avatar
Bryton Lacquement committed
1504
    schema = bytes2str(pkg_resources.resource_string(
1505
      'slapos.tests',
1506 1507
      os.path.join('test_slapproxy', self.dump_filename)
    ))
1508
    self.db = sqlite_connect(self.proxy_db)
1509 1510 1511 1512
    self.db.cursor().executescript(schema)
    self.db.commit()

  def test_automatic_migration(self):
1513 1514 1515 1516 1517
    # Make sure that in the initial state we only have current version of the tables.
    table_list = self.db.execute("SELECT name FROM sqlite_master WHERE type='table' ORDER BY name").fetchall()
    self.assertEqual([x[0] for x in table_list], self.initial_table_list)

    # create an old table, to assert it is also properly removed.
1518 1519 1520
    self.db.execute("create table software9 (int a)")
    self.db.commit()

1521
    # Run a dummy request to cause migration
1522 1523 1524 1525 1526 1527 1528 1529 1530 1531 1532 1533 1534
    from slapos.proxy.views import app
    with mock.patch.object(app.logger, 'info') as logger:
      self.app.get('/getComputerInformation?computer_id=computer')

    # This creates a backup dump
    logger.assert_has_calls((
        mock.call('Old schema detected: Creating a backup of current tables at %s', mock.ANY),
        mock.call('Old schema detected: Migrating old tables...')))
    backup_name = logger.call_args_list[0][0][1]
    with open(backup_name, 'rt') as f:
      dump = f.read()
      self.assertIn("CREATE TABLE", dump)
      self.assertIn('INSERT INTO', dump)
1535 1536 1537 1538 1539 1540

    # Check some partition parameters
    self.assertEqual(
        loads(self.app.get('/getComputerInformation?computer_id=computer').data)._computer_partition_list[0]._parameter_dict['slap_software_type'],
        'production'
    )
1541

1542
    # Lower level tests
1543
    computer_list = self.db.execute("SELECT * FROM computer{}".format(self.current_version)).fetchall()
1544 1545 1546 1547 1548
    self.assertEqual(
        computer_list,
        [(u'computer', u'127.0.0.1', u'255.255.255.255')]
    )

1549
    software_list = self.db.execute("SELECT * FROM software{}".format(self.current_version)).fetchall()
1550 1551
    self.assertEqual(
        software_list,
1552
        [(u'/srv/slapgrid//srv//runner/project//slapos/software.cfg', u'computer', u'available')]
1553 1554
    )

1555
    partition_list = self.db.execute("select * from partition{}".format(self.current_version)).fetchall()
1556 1557 1558 1559 1560 1561 1562 1563 1564 1565 1566 1567
    self.assertEqual(partition_list, [
      ('slappart0', 'computer', 'busy', '/srv/slapgrid//srv//runner/project//slapos/software.cfg', '<?xml version=\'1.0\' encoding=\'utf-8\'?>\n<instance>\n  <parameter id="json">{\n  "site-id": "erp5"\n  }\n}</parameter>\n</instance>\n', None, None, 'production', 'slapos', None, 'started', None),
      ('slappart1', 'computer', 'busy', '/srv/slapgrid//srv//runner/project//slapos/software.cfg', "<?xml version='1.0' encoding='utf-8'?>\n<instance/>\n", '<?xml version=\'1.0\' encoding=\'utf-8\'?>\n<instance>\n  <parameter id="url">mysql://127.0.0.1:45678/erp5</parameter>\n</instance>\n', None, 'mariadb', 'MariaDB DataBase', 'slappart0', 'started', None),
      ('slappart2', 'computer', 'busy', '/srv/slapgrid//srv//runner/project//slapos/software.cfg', '<?xml version=\'1.0\' encoding=\'utf-8\'?>\n<instance>\n  <parameter id="cloudooo-json"></parameter>\n</instance>\n', '<?xml version=\'1.0\' encoding=\'utf-8\'?>\n<instance>\n  <parameter id="url">cloudooo://127.0.0.1:23000/</parameter>\n</instance>\n', None, 'cloudooo', 'Cloudooo', 'slappart0', 'started', None),
      ('slappart3', 'computer', 'busy', '/srv/slapgrid//srv//runner/project//slapos/software.cfg', "<?xml version='1.0' encoding='utf-8'?>\n<instance/>\n", '<?xml version=\'1.0\' encoding=\'utf-8\'?>\n<instance>\n  <parameter id="url">memcached://127.0.0.1:11000/</parameter>\n</instance>\n', None, 'memcached', 'Memcached', 'slappart0', 'started', None),
      ('slappart4', 'computer', 'busy', '/srv/slapgrid//srv//runner/project//slapos/software.cfg', "<?xml version='1.0' encoding='utf-8'?>\n<instance/>\n", '<?xml version=\'1.0\' encoding=\'utf-8\'?>\n<instance>\n  <parameter id="url">memcached://127.0.0.1:13301/</parameter>\n</instance>\n', None, 'kumofs', 'KumoFS', 'slappart0', 'started', None),
      ('slappart5', 'computer', 'busy', '/srv/slapgrid//srv//runner/project//slapos/software.cfg', '<?xml version=\'1.0\' encoding=\'utf-8\'?>\n<instance>\n  <parameter id="kumofs-url">memcached://127.0.0.1:13301/</parameter>\n  <parameter id="memcached-url">memcached://127.0.0.1:11000/</parameter>\n  <parameter id="cloudooo-url">cloudooo://127.0.0.1:23000/</parameter>\n</instance>\n', '<?xml version=\'1.0\' encoding=\'utf-8\'?>\n<instance>\n  <parameter id="url">https://[fc00::1]:10001</parameter>\n</instance>\n', None, 'tidstorage', 'TidStorage', 'slappart0', 'started', None),
      ('slappart6', 'computer', 'free', None, None, None, None, None, None, None, 'started', None),
      ('slappart7', 'computer', 'free', None, None, None, None, None, None, None, 'started', None),
      ('slappart8', 'computer', 'free', None, None, None, None, None, None, None, 'started', None),
      ('slappart9', 'computer', 'free', None, None, None, None, None, None, None, 'started', None),
      ])
1568

1569
    slave_list = self.db.execute("select * from slave{}".format(self.current_version)).fetchall()
1570 1571 1572 1573 1574
    self.assertEqual(
        slave_list,
        []
    )

1575
    partition_network_list = self.db.execute("select * from partition_network{}".format(self.current_version)).fetchall()
1576 1577 1578 1579 1580
    self.assertEqual(
        partition_network_list,
        [(u'slappart0', u'computer', u'slappart0', u'127.0.0.1', u'255.255.255.255'), (u'slappart0', u'computer', u'slappart0', u'fc00::1', u'ffff:ffff:ffff::'), (u'slappart1', u'computer', u'slappart1', u'127.0.0.1', u'255.255.255.255'), (u'slappart1', u'computer', u'slappart1', u'fc00::1', u'ffff:ffff:ffff::'), (u'slappart2', u'computer', u'slappart2', u'127.0.0.1', u'255.255.255.255'), (u'slappart2', u'computer', u'slappart2', u'fc00::1', u'ffff:ffff:ffff::'), (u'slappart3', u'computer', u'slappart3', u'127.0.0.1', u'255.255.255.255'), (u'slappart3', u'computer', u'slappart3', u'fc00::1', u'ffff:ffff:ffff::'), (u'slappart4', u'computer', u'slappart4', u'127.0.0.1', u'255.255.255.255'), (u'slappart4', u'computer', u'slappart4', u'fc00::1', u'ffff:ffff:ffff::'), (u'slappart5', u'computer', u'slappart5', u'127.0.0.1', u'255.255.255.255'), (u'slappart5', u'computer', u'slappart5', u'fc00::1', u'ffff:ffff:ffff::'), (u'slappart6', u'computer', u'slappart6', u'127.0.0.1', u'255.255.255.255'), (u'slappart6', u'computer', u'slappart6', u'fc00::1', u'ffff:ffff:ffff::'), (u'slappart7', u'computer', u'slappart7', u'127.0.0.1', u'255.255.255.255'), (u'slappart7', u'computer', u'slappart7', u'fc00::1', u'ffff:ffff:ffff::'), (u'slappart8', u'computer', u'slappart8', u'127.0.0.1', u'255.255.255.255'), (u'slappart8', u'computer', u'slappart8', u'fc00::1', u'ffff:ffff:ffff::'), (u'slappart9', u'computer', u'slappart9', u'127.0.0.1', u'255.255.255.255'), (u'slappart9', u'computer', u'slappart9', u'fc00::1', u'ffff:ffff:ffff::')]
    )

1581 1582
    # Check that we only have new tables
    table_list = self.db.execute("SELECT name FROM sqlite_master WHERE type='table' ORDER BY name").fetchall()
1583 1584 1585 1586 1587 1588 1589 1590
    self.assertEqual([x[0] for x in table_list],
       ['computer{}'.format(self.current_version),
        'forwarded_partition_request{}'.format(self.current_version),
        'partition{}'.format(self.current_version),
        'partition_network{}'.format(self.current_version),
        'slave{}'.format(self.current_version),
        'software{}'.format(self.current_version),
      ])
1591

1592 1593 1594 1595 1596 1597 1598 1599 1600 1601 1602 1603 1604 1605 1606 1607 1608 1609 1610 1611 1612
  # Override several tests that needs an empty database
  @unittest.skip("Not implemented")
  def test_multi_node_support_different_software_release_list(self):
    pass

  @unittest.skip("Not implemented")
  def test_multi_node_support_instance_default_computer(self):
    pass

  @unittest.skip("Not implemented")
  def test_multi_node_support_instance_guid(self):
    pass

  @unittest.skip("Not implemented")
  def test_partition_are_empty(self):
    pass

  @unittest.skip("Not implemented")
  def test_request_consistent_parameters(self):
    pass

1613 1614 1615 1616 1617 1618 1619 1620 1621 1622 1623

class TestMigrateVersion10ToLatest(_MigrationTestCase):
  dump_filename = 'database_dump_version_10.sql'
  initial_table_list = ['computer10', 'partition10', 'partition_network10', 'slave10', 'software10', ]


class TestMigrateVersion11ToLatest(_MigrationTestCase):
  dump_filename = 'database_dump_version_11.sql'
  initial_table_list = ['computer11', 'forwarded_partition_request11', 'partition11', 'partition_network11', 'slave11', 'software11', ]


1624 1625 1626 1627 1628
class TestMigrateVersion12ToLatest(_MigrationTestCase):
  dump_filename = 'database_dump_version_12.sql'
  initial_table_list = ['computer12', 'forwarded_partition_request12', 'partition12', 'partition_network12', 'slave12', 'software12', ]


1629 1630 1631 1632 1633 1634
class TestMigrateVersion13ToLatest(_MigrationTestCase):
  dump_filename = 'database_dump_version_13.sql'
  initial_table_list = ['computer13', 'forwarded_partition_request13', 'partition13', 'partition_network13', 'slave13', 'software13', ]


del _MigrationTestCase