~juju-qa/juju-ci-tools/trunk : revision 1493.1.1

103

return wrapper

104

105

106

class AdminOperation(Exception):

106

class ControllerOperation(Exception):

107

108

def __init__(self, operation):

109

super(AdminOperation, self).__init__(

110

'Operation "{}" can only be performed on admin models.'.format(

109

super(ControllerOperation, self).__init__(

110

'Operation "{}" is only valid on controller models.'.format(

111

operation))

112

113

134

state.controller.state = 'created'

135

return state

136

137

def require_admin(self, operation, name):

138

if name != self.admin_model.name:

139

raise AdminOperation(operation)

137

def require_controller(self, operation, name):

138

if name != self.controller_model.name:

139

raise ControllerOperation(operation)

140

141

def bootstrap(self, model_name, config, separate_admin):

141

def bootstrap(self, model_name, config, separate_controller):

142

default_model = self.add_model(model_name)

143

default_model.name = model_name

144

if separate_admin:

145

admin_model = default_model.controller.add_model('controller')

144

if separate_controller:

145

controller_model = default_model.controller.add_model('controller')

146

else:

147

admin_model = default_model

148

self.admin_model = admin_model

149

admin_model.state_servers.append(admin_model.add_machine())

147

controller_model = default_model

148

self.controller_model = controller_model

149

controller_model.state_servers.append(controller_model.add_machine())

150

self.state = 'bootstrapped'

151

default_model.model_config = copy.deepcopy(config)

152

self.models[default_model.name] = default_model

234

self.controller.state = 'model-destroyed'

235

236

def restore_backup(self):

237

self.controller.require_admin('restore', self.name)

237

self.controller.require_controller('restore', self.name)

238

if len(self.state_servers) > 0:

239

exc = subprocess.CalledProcessError('Operation not permitted', 1,

240

2)

242

raise exc

243

244

def enable_ha(self):

245

self.controller.require_admin('enable-ha', self.name)

245

self.controller.require_controller('enable-ha', self.name)

246

for n in range(2):

247

self.state_servers.append(self.add_machine())

248

420

for x in range(parsed.count):

421

model_state.add_machine()

422

423

def get_admin_model_name(self):

424

return self.controller_state.admin_model.name

423

def get_controller_model_name(self):

424

return self.controller_state.controller_model.name

425

426

def make_controller_dict(self, controller_name):

427

admin_model = self.controller_state.admin_model

428

server_id = list(admin_model.state_servers)[0]

429

server_hostname = admin_model.machine_host_names[server_id]

427

controller_model = self.controller_state.controller_model

428

server_id = list(controller_model.state_servers)[0]

429

server_hostname = controller_model.machine_host_names[server_id]

430

api_endpoint = '{}:23'.format(server_hostname)

431

return {controller_name: {'details': {'api-endpoints': [

432

api_endpoint]}}}

579

# subset of YAML, so emit JSON.

580

return json.dumps(status_dict)

581

if command == 'create-backup':

582

self.controller_state.require_admin('backup', model)

582

self.controller_state.require_controller('backup', model)

583

return 'juju-backup-0.tar.gz'

584

return ''

585

658

659

class FakeJujuClientOptionalJES(EnvJujuClient):

660

661

def get_admin_model_name(self):

662

return self._backend.controller_state.admin_model.name

661

def get_controller_model_name(self):

662

return self._backend.controller_state.controller_model.name

663

664

665

class TestErroredUnit(TestCase):

1228

full = client._full_args('bar', True, ('baz', 'qux'))

1229

self.assertEqual((

1230

'bin', '--show-log', 'bar', '-m', 'foo:foo', 'baz', 'qux'), full)

1231

full = client._full_args('bar', True, ('baz', 'qux'), admin=True)

1231

full = client._full_args('bar', True, ('baz', 'qux'), controller=True)

1232

self.assertEqual(

1233

('bin', '--show-log', 'bar', '-m', 'foo:controller', 'baz', 'qux'),

1234

full)

1252

'baz', 'qux'),

1253

full)

1254

1255

def test_full_args_admin(self):

1255

def test_full_args_controller(self):

1256

env = JujuData('foo')

1257

client = EnvJujuClient(env, None, 'my/juju/bin')

1258

with patch.object(client, 'get_admin_model_name',

1258

with patch.object(client, 'get_controller_model_name',

1259

return_value='controller') as gamn_mock:

1260

full = client._full_args('bar', False, ('baz', 'qux'), admin=True)

1260

full = client._full_args('bar', False, ('baz', 'qux'),

1261

controller=True)

1261

1262

self.assertEqual((

1262

1263

'bin', '--show-log', 'bar', '-m', 'foo:controller', 'baz', 'qux'),

1263

1264

full)

1593

1594

return_value=output_text) as gjo_mock:

1594

1595

result = client.get_status()

1595

1596

gjo_mock.assert_called_once_with(

1596

'show-status', '--format', 'yaml', admin=False)

1597

'show-status', '--format', 'yaml', controller=False)

1597

1598

self.assertEqual(Status, type(result))

1598

1599

self.assertEqual(['a', 'b', 'c'], result.status)

1599

1600

2227

2228

self.assertIs(client, model_clients[0])

2228

2229

self.assertEqual('bar', model_clients[1].env.environment)

2229

2230

def test_get_admin_model_name(self):

2231

def test_get_controller_model_name(self):

2231

2232

models = {

2232

2233

'models': [

2233

2234

{'name': 'controller', 'model-uuid': 'aaaa'},

2237

2238

client = EnvJujuClient(JujuData('foo'), None, None)

2238

2239

with patch.object(client, 'get_models',

2239

2240

return_value=models) as gm_mock:

2240

admin_name = client.get_admin_model_name()

2241

controller_name = client.get_controller_model_name()

2241

2242

self.assertEqual(0, gm_mock.call_count)

2242

self.assertEqual('controller', admin_name)

2243

self.assertEqual('controller', controller_name)

2243

2244

def test_get_admin_model_name_without_admin(self):

2245

def test_get_controller_model_name_without_controller(self):

2245

2246

models = {

2246

2247

'models': [

2247

2248

{'name': 'bar', 'model-uuid': 'aaaa'},

2250

2251

}

2251

2252

client = EnvJujuClient(JujuData('foo'), None, None)

2252

2253

with patch.object(client, 'get_models', return_value=models):

2253

admin_name = client.get_admin_model_name()

2254

self.assertEqual('controller', admin_name)

2254

controller_name = client.get_controller_model_name()

2255

self.assertEqual('controller', controller_name)

2255

2256

def test_get_admin_model_name_no_models(self):

2257

def test_get_controller_model_name_no_models(self):

2257

2258

client = EnvJujuClient(JujuData('foo'), None, None)

2258

2259

with patch.object(client, 'get_models', return_value={}):

2259

admin_name = client.get_admin_model_name()

2260

self.assertEqual('controller', admin_name)

2260

controller_name = client.get_controller_model_name()

2261

self.assertEqual('controller', controller_name)

2261

2262

def test_get_admin_client(self):

2263

def test_get_controller_client(self):

2263

2264

client = EnvJujuClient(

2264

2265

JujuData('foo', {'bar': 'baz'}, 'myhome'), None, None)

2265

admin_client = client.get_admin_client()

2266

admin_env = admin_client.env

2267

self.assertEqual('controller', admin_env.environment)

2266

controller_client = client.get_controller_client()

2267

controller_env = controller_client.env

2268

self.assertEqual('controller', controller_env.environment)

2268

2269

self.assertEqual(

2269

{'bar': 'baz', 'name': 'controller'}, admin_env.config)

2270

{'bar': 'baz', 'name': 'controller'}, controller_env.config)

2270

2271

2272

def test_list_controllers(self):

2272

2273

client = EnvJujuClient(JujuData('foo'), None, None)

2309

2310

api-endpoints: ['[::1]:17070', '[fe80::216:3eff:0:9dc7]:17070']

2310

2311

"""

2311

2312

client = EnvJujuClient(JujuData('foo', {}), None, None)

2312

admin_client = client.get_admin_client()

2313

controller_client = client.get_controller_client()

2313

2314

client.env.controller.name = 'bar'

2314

with patch.object(admin_client, 'get_juju_output',

2315

with patch.object(controller_client, 'get_juju_output',

2315

2316

return_value=data) as gjo:

2316

endpoint = admin_client.get_controller_endpoint()

2317

endpoint = controller_client.get_controller_endpoint()

2317

2318

gjo.assert_called_once_with('show-controller', 'bar',

2318

2319

include_e=False)

2319

2320

self.assertEqual('::1', endpoint)

2320

2321

2322

def test_get_controller_members(self):

2322

2323

status = Status.from_text("""\

2323

model: admin

2324

model: controller

2324

2325

machines:

2325

2326

"0":

2326

2327

dns-name: 10.0.0.0

2370

2371

2372

def test_get_controller_members_one(self):

2372

2373

status = Status.from_text("""\

2373

model: admin

2374

model: controller

2374

2375

machines:

2375

2376

"0":

2376

2377

dns-name: 10.0.0.0

2418

2419

return_value=value) as gjo_mock:

2419

2420

client.wait_for_ha()

2420

2421

gjo_mock.assert_called_once_with(

2421

'show-status', '--format', 'yaml', admin=True)

2422

'show-status', '--format', 'yaml', controller=True)

2422

2423

2424

def test_wait_for_ha_no_has_vote(self):

2424

2425

value = yaml.safe_dump({

3266

3267

3268

class TestEnvJujuClient2B7(ClientTest):

3268

3269

def test_get_admin_model_name(self):

3270

def test_get_controller_model_name(self):

3270

3271

models = {

3271

3272

'models': [

3272

3273

{'name': 'admin', 'model-uuid': 'aaaa'},

3276

3277

client = EnvJujuClient2B7(JujuData('foo'), None, None)

3277

3278

with patch.object(client, 'get_models',

3278

3279

return_value=models) as gm_mock:

3279

admin_name = client.get_admin_model_name()

3280

controller_name = client.get_controller_model_name()

3280

3281

self.assertEqual(0, gm_mock.call_count)

3281

self.assertEqual('admin', admin_name)

3282

self.assertEqual('admin', controller_name)

3282

3283

def test_get_admin_model_name_without_admin(self):

3284

def test_get_controller_model_name_without_controller(self):

3284

3285

models = {

3285

3286

'models': [

3286

3287

{'name': 'bar', 'model-uuid': 'aaaa'},

3289

3290

}

3290

3291

client = EnvJujuClient2B7(JujuData('foo'), None, None)

3291

3292

with patch.object(client, 'get_models', return_value=models):

3292

admin_name = client.get_admin_model_name()

3293

self.assertEqual('admin', admin_name)

3293

controller_name = client.get_controller_model_name()

3294

self.assertEqual('admin', controller_name)

3294

3295

def test_get_admin_model_name_no_models(self):

3296

def test_get_controller_model_name_no_models(self):

3296

3297

client = EnvJujuClient2B7(JujuData('foo'), None, None)

3297

3298

with patch.object(client, 'get_models', return_value={}):

3298

admin_name = client.get_admin_model_name()

3299

self.assertEqual('admin', admin_name)

3299

controller_name = client.get_controller_model_name()

3300

self.assertEqual('admin', controller_name)

3300

3301

def test_get_admin_client(self):

3302

def test_get_controller_client(self):

3302

3303

client = EnvJujuClient2B7(

3303

3304

JujuData('foo', {'bar': 'baz'}, 'myhome'), None, None)

3304

admin_client = client.get_admin_client()

3305

admin_env = admin_client.env

3306

self.assertEqual('admin', admin_env.environment)

3307

self.assertEqual({'bar': 'baz', 'name': 'admin'}, admin_env.config)

3305

controller_client = client.get_controller_client()

3306

controller_env = controller_client.env

3307

self.assertEqual('admin', controller_env.environment)

3308

self.assertEqual({'bar': 'baz', 'name': 'admin'},

3309

controller_env.config)

3308

3310

3309

3311

3310

3312

class TestEnvJujuClient2B3(ClientTest):

3431

3433

config = yaml.safe_load(config_file)

3432

3434

self.assertEqual({'test-mode': True}, config)

3433

3435

3434

def test_get_admin_model_name(self):

3436

def test_get_controller_model_name(self):

3435

3437

models = {

3436

3438

'models': [

3437

3439

{'name': 'admin', 'model-uuid': 'aaaa'},

3441

3443

client = EnvJujuClient2B2(JujuData('foo'), None, None)

3442

3444

with patch.object(client, 'get_models',

3443

3445

return_value=models) as gm_mock:

3444

admin_name = client.get_admin_model_name()

3446

controller_name = client.get_controller_model_name()

3445

3447

gm_mock.assert_called_once_with()

3446

self.assertEqual('admin', admin_name)

3448

self.assertEqual('admin', controller_name)

3447

3449

3448

def test_get_admin_model_name_without_admin(self):

3450

def test_get_controller_model_name_without_controller(self):

3449

3451

models = {

3450

3452

'models': [

3451

3453

{'name': 'bar', 'model-uuid': 'aaaa'},

3454

3456

}

3455

3457

client = EnvJujuClient2B2(JujuData('foo'), None, None)

3456

3458

with patch.object(client, 'get_models', return_value=models):

3457

admin_name = client.get_admin_model_name()

3458

self.assertEqual('foo', admin_name)

3459

controller_name = client.get_controller_model_name()

3460

self.assertEqual('foo', controller_name)

3459

3461

3460

def test_get_admin_model_name_no_models(self):

3462

def test_get_controller_model_name_no_models(self):

3461

3463

client = EnvJujuClient2B2(JujuData('foo'), None, None)

3462

3464

with patch.object(client, 'get_models', return_value={}):

3463

admin_name = client.get_admin_model_name()

3464

self.assertEqual('foo', admin_name)

3465

controller_name = client.get_controller_model_name()

3466

self.assertEqual('foo', controller_name)

3465

3467

3466

3468

3467

3469

class TestEnvJujuClient2A2(TestCase):

3690

3692

self.assertEqual((

3691

3693

'bin', '--debug', 'bar', '-e', 'foo', 'baz', 'qux'), full)

3692

3694

3693

def test_full_args_admin(self):

3695

def test_full_args_controller(self):

3694

3696

env = SimpleEnvironment('foo')

3695

3697

client = EnvJujuClient1X(env, None, 'my/juju/bin')

3696

full = client._full_args('bar', False, ('baz', 'qux'), admin=True)

3698

full = client._full_args('bar', False, ('baz', 'qux'), controller=True)

3697

3699

self.assertEqual((

3698

3700

'bin', '--show-log', 'bar', '-e', 'foo', 'baz', 'qux'), full)

3699

3701

3987

3989

return_value=output_text) as gjo_mock:

3988

3990

result = client.get_status()

3989

3991

gjo_mock.assert_called_once_with(

3990

'status', '--format', 'yaml', admin=False)

3992

'status', '--format', 'yaml', controller=False)

3991

3993

self.assertEqual(ServiceStatus, type(result))

3992

3994

self.assertEqual(['a', 'b', 'c'], result.status)

3993

3995

4029

4031

client.get_status(500)

4030

4032

mock_ut.assert_called_with(500)

4031

4033

4032

def test_get_status_admin(self):

4034

def test_get_status_controller(self):

4033

4035

output_text = """\

4034

4036

- a

4035

4037

- b

4039

4041

client = EnvJujuClient1X(env, None, None)

4040

4042

with patch.object(client, 'get_juju_output',

4041

4043

return_value=output_text) as gjo_mock:

4042

client.get_status(admin=True)

4044

client.get_status(controller=True)

4043

4045

gjo_mock.assert_called_once_with(

4044

'status', '--format', 'yaml', admin=True)

4046

'status', '--format', 'yaml', controller=True)

4045

4047

4046

4048

@staticmethod

4047

4049

def make_status_yaml(key, machine_value, unit_value):

5051

5053

self.assertIs(client, model_clients[0])

5052

5054

self.assertEqual('bar', model_clients[1].env.environment)

5053

5055

5054

def test_get_admin_model_name_no_models(self):

5056

def test_get_controller_model_name_no_models(self):

5055

5057

env = SimpleEnvironment('foo', {'type': 'local'})

5056

5058

client = EnvJujuClient1X(env, '1.23-series-arch', None)

5057

5059

with patch.object(client, 'get_models', return_value={}):

5058

admin_name = client.get_admin_model_name()

5059

self.assertEqual('foo', admin_name)

5060

controller_name = client.get_controller_model_name()

5061

self.assertEqual('foo', controller_name)

5060

5062

5061

def test_get_admin_client(self):

5063

def test_get_controller_client(self):

5062

5064

client = EnvJujuClient1X(SimpleEnvironment('foo'), {'bar': 'baz'},

5063

5065

'myhome')

5064

admin_client = client.get_admin_client()

5065

self.assertIs(client, admin_client)

5066

controller_client = client.get_controller_client()

5067

self.assertIs(client, controller_client)

5066

5068

5067

5069

def test_list_controllers(self):

5068

5070

env = SimpleEnvironment('foo', {'type': 'local'})