git.apps.os.sepia.ceph.com Git - ceph.git/blob

   1 import { HttpClientTestingModule } from '@angular/common/http/testing';
   2 import { ComponentFixture, TestBed } from '@angular/core/testing';
   3 import { ReactiveFormsModule } from '@angular/forms';
   4 import { By } from '@angular/platform-browser';
   5 import { RouterTestingModule } from '@angular/router/testing';
   6
   7 import { NgbActiveModal, NgbTypeaheadModule } from '@ng-bootstrap/ng-bootstrap';
   8 import _ from 'lodash';
   9 import { ToastrModule } from 'ngx-toastr';
  10
  11 import { CephServiceService } from '~/app/shared/api/ceph-service.service';
  12 import { CdFormGroup } from '~/app/shared/forms/cd-form-group';
  13 import { SharedModule } from '~/app/shared/shared.module';
  14 import { configureTestBed, FormHelper } from '~/testing/unit-test-helper';
  15 import { ServiceFormComponent } from './service-form.component';
  16
  17 describe('ServiceFormComponent', () => {
  18   let component: ServiceFormComponent;
  19   let fixture: ComponentFixture<ServiceFormComponent>;
  20   let cephServiceService: CephServiceService;
  21   let form: CdFormGroup;
  22   let formHelper: FormHelper;
  23
  24   configureTestBed({
  25     declarations: [ServiceFormComponent],
  26     providers: [NgbActiveModal],
  27     imports: [
  28       HttpClientTestingModule,
  29       NgbTypeaheadModule,
  30       ReactiveFormsModule,
  31       RouterTestingModule,
  32       SharedModule,
  33       ToastrModule.forRoot()
  34     ]
  35   });
  36
  37   beforeEach(() => {
  38     fixture = TestBed.createComponent(ServiceFormComponent);
  39     component = fixture.componentInstance;
  40     component.ngOnInit();
  41     form = component.serviceForm;
  42     formHelper = new FormHelper(form);
  43     fixture.detectChanges();
  44   });
  45
  46   it('should create', () => {
  47     expect(component).toBeTruthy();
  48   });
  49
  50   describe('should test form', () => {
  51     beforeEach(() => {
  52       cephServiceService = TestBed.inject(CephServiceService);
  53       spyOn(cephServiceService, 'create').and.stub();
  54     });
  55
  56     it('should test placement (host)', () => {
  57       formHelper.setValue('service_type', 'crash');
  58       formHelper.setValue('placement', 'hosts');
  59       formHelper.setValue('hosts', ['mgr0', 'mon0', 'osd0']);
  60       formHelper.setValue('count', 2);
  61       component.onSubmit();
  62       expect(cephServiceService.create).toHaveBeenCalledWith({
  63         service_type: 'crash',
  64         placement: {
  65           hosts: ['mgr0', 'mon0', 'osd0'],
  66           count: 2
  67         },
  68         unmanaged: false
  69       });
  70     });
  71
  72     it('should test placement (label)', () => {
  73       formHelper.setValue('service_type', 'mgr');
  74       formHelper.setValue('placement', 'label');
  75       formHelper.setValue('label', 'foo');
  76       component.onSubmit();
  77       expect(cephServiceService.create).toHaveBeenCalledWith({
  78         service_type: 'mgr',
  79         placement: {
  80           label: 'foo'
  81         },
  82         unmanaged: false
  83       });
  84     });
  85
  86     it('should submit valid count', () => {
  87       formHelper.setValue('count', 1);
  88       component.onSubmit();
  89       formHelper.expectValid('count');
  90     });
  91
  92     it('should submit invalid count (1)', () => {
  93       formHelper.setValue('count', 0);
  94       component.onSubmit();
  95       formHelper.expectError('count', 'min');
  96     });
  97
  98     it('should submit invalid count (2)', () => {
  99       formHelper.setValue('count', 'abc');
 100       component.onSubmit();
 101       formHelper.expectError('count', 'pattern');
 102     });
 103
 104     it('should test unmanaged', () => {
 105       formHelper.setValue('service_type', 'mgr');
 106       formHelper.setValue('service_id', 'svc');
 107       formHelper.setValue('placement', 'label');
 108       formHelper.setValue('label', 'bar');
 109       formHelper.setValue('unmanaged', true);
 110       component.onSubmit();
 111       expect(cephServiceService.create).toHaveBeenCalledWith({
 112         service_type: 'mgr',
 113         service_id: 'svc',
 114         placement: {},
 115         unmanaged: true
 116       });
 117     });
 118
 119     it('should test various services', () => {
 120       _.forEach(
 121         [
 122           'alertmanager',
 123           'crash',
 124           'grafana',
 125           'mds',
 126           'mgr',
 127           'mon',
 128           'node-exporter',
 129           'prometheus',
 130           'rbd-mirror'
 131         ],
 132         (serviceType) => {
 133           formHelper.setValue('service_type', serviceType);
 134           component.onSubmit();
 135           expect(cephServiceService.create).toHaveBeenCalledWith({
 136             service_type: serviceType,
 137             placement: {},
 138             unmanaged: false
 139           });
 140         }
 141       );
 142     });
 143
 144     describe('should test service nfs', () => {
 145       beforeEach(() => {
 146         formHelper.setValue('service_type', 'nfs');
 147       });
 148
 149       it('should submit nfs', () => {
 150         component.onSubmit();
 151         expect(cephServiceService.create).toHaveBeenCalledWith({
 152           service_type: 'nfs',
 153           placement: {},
 154           unmanaged: false
 155         });
 156       });
 157     });
 158
 159     describe('should test service rgw', () => {
 160       beforeEach(() => {
 161         formHelper.setValue('service_type', 'rgw');
 162         formHelper.setValue('service_id', 'svc');
 163       });
 164
 165       it('should test rgw valid service id', () => {
 166         formHelper.setValue('service_id', 'svc.realm.zone');
 167         formHelper.expectValid('service_id');
 168         formHelper.setValue('service_id', 'svc');
 169         formHelper.expectValid('service_id');
 170       });
 171
 172       it('should test rgw invalid service id', () => {
 173         formHelper.setValue('service_id', '.');
 174         formHelper.expectError('service_id', 'rgwPattern');
 175         formHelper.setValue('service_id', 'svc.');
 176         formHelper.expectError('service_id', 'rgwPattern');
 177         formHelper.setValue('service_id', 'svc.realm');
 178         formHelper.expectError('service_id', 'rgwPattern');
 179         formHelper.setValue('service_id', 'svc.realm.');
 180         formHelper.expectError('service_id', 'rgwPattern');
 181         formHelper.setValue('service_id', '.svc.realm');
 182         formHelper.expectError('service_id', 'rgwPattern');
 183         formHelper.setValue('service_id', 'svc.realm.zone.');
 184         formHelper.expectError('service_id', 'rgwPattern');
 185       });
 186
 187       it('should submit rgw with realm and zone', () => {
 188         formHelper.setValue('service_id', 'svc.my-realm.my-zone');
 189         component.onSubmit();
 190         expect(cephServiceService.create).toHaveBeenCalledWith({
 191           service_type: 'rgw',
 192           service_id: 'svc',
 193           rgw_realm: 'my-realm',
 194           rgw_zone: 'my-zone',
 195           placement: {},
 196           unmanaged: false,
 197           ssl: false
 198         });
 199       });
 200
 201       it('should submit rgw with port and ssl enabled', () => {
 202         formHelper.setValue('rgw_frontend_port', 1234);
 203         formHelper.setValue('ssl', true);
 204         component.onSubmit();
 205         expect(cephServiceService.create).toHaveBeenCalledWith({
 206           service_type: 'rgw',
 207           service_id: 'svc',
 208           placement: {},
 209           unmanaged: false,
 210           rgw_frontend_port: 1234,
 211           rgw_frontend_ssl_certificate: '',
 212           ssl: true
 213         });
 214       });
 215
 216       it('should submit valid rgw port (1)', () => {
 217         formHelper.setValue('rgw_frontend_port', 1);
 218         component.onSubmit();
 219         formHelper.expectValid('rgw_frontend_port');
 220       });
 221
 222       it('should submit valid rgw port (2)', () => {
 223         formHelper.setValue('rgw_frontend_port', 65535);
 224         component.onSubmit();
 225         formHelper.expectValid('rgw_frontend_port');
 226       });
 227
 228       it('should submit invalid rgw port (1)', () => {
 229         formHelper.setValue('rgw_frontend_port', 0);
 230         fixture.detectChanges();
 231         formHelper.expectError('rgw_frontend_port', 'min');
 232       });
 233
 234       it('should submit invalid rgw port (2)', () => {
 235         formHelper.setValue('rgw_frontend_port', 65536);
 236         fixture.detectChanges();
 237         formHelper.expectError('rgw_frontend_port', 'max');
 238       });
 239
 240       it('should submit invalid rgw port (3)', () => {
 241         formHelper.setValue('rgw_frontend_port', 'abc');
 242         component.onSubmit();
 243         formHelper.expectError('rgw_frontend_port', 'pattern');
 244       });
 245
 246       it('should submit rgw w/o port', () => {
 247         formHelper.setValue('ssl', false);
 248         component.onSubmit();
 249         expect(cephServiceService.create).toHaveBeenCalledWith({
 250           service_type: 'rgw',
 251           service_id: 'svc',
 252           placement: {},
 253           unmanaged: false,
 254           ssl: false
 255         });
 256       });
 257
 258       it('should not show private key field', () => {
 259         formHelper.setValue('ssl', true);
 260         fixture.detectChanges();
 261         const ssl_key = fixture.debugElement.query(By.css('#ssl_key'));
 262         expect(ssl_key).toBeNull();
 263       });
 264
 265       it('should test .pem file', () => {
 266         const pemCert = `
 267 -----BEGIN CERTIFICATE-----
 268 iJ5IbgzlKPssdYwuAEI3yPZxX/g5vKBrgcyD3LttLL/DlElq/1xCnwVrv7WROSNu
 269 -----END CERTIFICATE-----
 270 -----BEGIN CERTIFICATE-----
 271 mn/S7BNBEC7AGe5ajmN+8hBTGdACUXe8rwMNrtTy/MwBZ0VpJsAAjJh+aptZh5yB
 272 -----END CERTIFICATE-----
 273 -----BEGIN RSA PRIVATE KEY-----
 274 x4Ea7kGVgx9kWh5XjWz9wjZvY49UKIT5ppIAWPMbLl3UpfckiuNhTA==
 275 -----END RSA PRIVATE KEY-----`;
 276         formHelper.setValue('ssl', true);
 277         formHelper.setValue('ssl_cert', pemCert);
 278         fixture.detectChanges();
 279         formHelper.expectValid('ssl_cert');
 280       });
 281     });
 282
 283     describe('should test service iscsi', () => {
 284       beforeEach(() => {
 285         formHelper.setValue('service_type', 'iscsi');
 286         formHelper.setValue('pool', 'xyz');
 287         formHelper.setValue('api_user', 'user');
 288         formHelper.setValue('api_password', 'password');
 289         formHelper.setValue('ssl', false);
 290       });
 291
 292       it('should submit iscsi', () => {
 293         component.onSubmit();
 294         expect(cephServiceService.create).toHaveBeenCalledWith({
 295           service_type: 'iscsi',
 296           placement: {},
 297           unmanaged: false,
 298           pool: 'xyz',
 299           api_user: 'user',
 300           api_password: 'password',
 301           api_secure: false
 302         });
 303       });
 304
 305       it('should submit iscsi with trusted ips', () => {
 306         formHelper.setValue('ssl', true);
 307         formHelper.setValue('trusted_ip_list', ' 172.16.0.5, 192.1.1.10  ');
 308         component.onSubmit();
 309         expect(cephServiceService.create).toHaveBeenCalledWith({
 310           service_type: 'iscsi',
 311           placement: {},
 312           unmanaged: false,
 313           pool: 'xyz',
 314           api_user: 'user',
 315           api_password: 'password',
 316           api_secure: true,
 317           ssl_cert: '',
 318           ssl_key: '',
 319           trusted_ip_list: '172.16.0.5, 192.1.1.10'
 320         });
 321       });
 322
 323       it('should submit iscsi with port', () => {
 324         formHelper.setValue('api_port', 456);
 325         component.onSubmit();
 326         expect(cephServiceService.create).toHaveBeenCalledWith({
 327           service_type: 'iscsi',
 328           placement: {},
 329           unmanaged: false,
 330           pool: 'xyz',
 331           api_user: 'user',
 332           api_password: 'password',
 333           api_secure: false,
 334           api_port: 456
 335         });
 336       });
 337
 338       it('should submit valid iscsi port (1)', () => {
 339         formHelper.setValue('api_port', 1);
 340         component.onSubmit();
 341         formHelper.expectValid('api_port');
 342       });
 343
 344       it('should submit valid iscsi port (2)', () => {
 345         formHelper.setValue('api_port', 65535);
 346         component.onSubmit();
 347         formHelper.expectValid('api_port');
 348       });
 349
 350       it('should submit invalid iscsi port (1)', () => {
 351         formHelper.setValue('api_port', 0);
 352         fixture.detectChanges();
 353         formHelper.expectError('api_port', 'min');
 354       });
 355
 356       it('should submit invalid iscsi port (2)', () => {
 357         formHelper.setValue('api_port', 65536);
 358         fixture.detectChanges();
 359         formHelper.expectError('api_port', 'max');
 360       });
 361
 362       it('should submit invalid iscsi port (3)', () => {
 363         formHelper.setValue('api_port', 'abc');
 364         component.onSubmit();
 365         formHelper.expectError('api_port', 'pattern');
 366       });
 367
 368       it('should throw error when there is no pool', () => {
 369         formHelper.expectErrorChange('pool', '', 'required');
 370       });
 371     });
 372
 373     describe('should test service ingress', () => {
 374       beforeEach(() => {
 375         formHelper.setValue('service_type', 'ingress');
 376         formHelper.setValue('backend_service', 'rgw.foo');
 377         formHelper.setValue('virtual_ip', '192.168.20.1/24');
 378         formHelper.setValue('ssl', false);
 379       });
 380
 381       it('should submit ingress', () => {
 382         component.onSubmit();
 383         expect(cephServiceService.create).toHaveBeenCalledWith({
 384           service_type: 'ingress',
 385           placement: {},
 386           unmanaged: false,
 387           backend_service: 'rgw.foo',
 388           service_id: 'rgw.foo',
 389           virtual_ip: '192.168.20.1/24',
 390           virtual_interface_networks: null,
 391           ssl: false
 392         });
 393       });
 394
 395       it('should pre-populate the service id', () => {
 396         component.prePopulateId();
 397         const prePopulatedID = component.serviceForm.getValue('service_id');
 398         expect(prePopulatedID).toBe('rgw.foo');
 399       });
 400
 401       it('should submit valid frontend and monitor port', () => {
 402         // min value
 403         formHelper.setValue('frontend_port', 1);
 404         formHelper.setValue('monitor_port', 1);
 405         fixture.detectChanges();
 406         formHelper.expectValid('frontend_port');
 407         formHelper.expectValid('monitor_port');
 408
 409         // max value
 410         formHelper.setValue('frontend_port', 65535);
 411         formHelper.setValue('monitor_port', 65535);
 412         fixture.detectChanges();
 413         formHelper.expectValid('frontend_port');
 414         formHelper.expectValid('monitor_port');
 415       });
 416
 417       it('should submit invalid frontend and monitor port', () => {
 418         // min
 419         formHelper.setValue('frontend_port', 0);
 420         formHelper.setValue('monitor_port', 0);
 421         fixture.detectChanges();
 422         formHelper.expectError('frontend_port', 'min');
 423         formHelper.expectError('monitor_port', 'min');
 424
 425         // max
 426         formHelper.setValue('frontend_port', 65536);
 427         formHelper.setValue('monitor_port', 65536);
 428         fixture.detectChanges();
 429         formHelper.expectError('frontend_port', 'max');
 430         formHelper.expectError('monitor_port', 'max');
 431
 432         // pattern
 433         formHelper.setValue('frontend_port', 'abc');
 434         formHelper.setValue('monitor_port', 'abc');
 435         component.onSubmit();
 436         formHelper.expectError('frontend_port', 'pattern');
 437         formHelper.expectError('monitor_port', 'pattern');
 438       });
 439     });
 440
 441     describe('should test service snmp-gateway', () => {
 442       beforeEach(() => {
 443         formHelper.setValue('service_type', 'snmp-gateway');
 444         formHelper.setValue('snmp_destination', '192.168.20.1:8443');
 445       });
 446
 447       it('should test snmp-gateway service with V2c', () => {
 448         formHelper.setValue('snmp_version', 'V2c');
 449         formHelper.setValue('snmp_community', 'public');
 450         component.onSubmit();
 451         expect(cephServiceService.create).toHaveBeenCalledWith({
 452           service_type: 'snmp-gateway',
 453           placement: {},
 454           unmanaged: false,
 455           snmp_version: 'V2c',
 456           snmp_destination: '192.168.20.1:8443',
 457           credentials: {
 458             snmp_community: 'public'
 459           }
 460         });
 461       });
 462       it('should test snmp-gateway service with V3', () => {
 463         formHelper.setValue('snmp_version', 'V3');
 464         formHelper.setValue('engine_id', '800C53F00000');
 465         formHelper.setValue('auth_protocol', 'SHA');
 466         formHelper.setValue('privacy_protocol', 'DES');
 467         formHelper.setValue('snmp_v3_auth_username', 'testuser');
 468         formHelper.setValue('snmp_v3_auth_password', 'testpass');
 469         formHelper.setValue('snmp_v3_priv_password', 'testencrypt');
 470         component.onSubmit();
 471         expect(cephServiceService.create).toHaveBeenCalledWith({
 472           service_type: 'snmp-gateway',
 473           placement: {},
 474           unmanaged: false,
 475           snmp_version: 'V3',
 476           snmp_destination: '192.168.20.1:8443',
 477           engine_id: '800C53F00000',
 478           auth_protocol: 'SHA',
 479           privacy_protocol: 'DES',
 480           credentials: {
 481             snmp_v3_auth_username: 'testuser',
 482             snmp_v3_auth_password: 'testpass',
 483             snmp_v3_priv_password: 'testencrypt'
 484           }
 485         });
 486       });
 487     });
 488
 489     describe('check edit fields', () => {
 490       beforeEach(() => {
 491         component.editing = true;
 492       });
 493
 494       it('should check whether edit field is correctly loaded', () => {
 495         const cephServiceSpy = spyOn(cephServiceService, 'list').and.callThrough();
 496         component.ngOnInit();
 497         expect(cephServiceSpy).toBeCalledTimes(2);
 498         expect(component.action).toBe('Edit');
 499         const serviceType = fixture.debugElement.query(By.css('#service_type')).nativeElement;
 500         const serviceId = fixture.debugElement.query(By.css('#service_id')).nativeElement;
 501         expect(serviceType.disabled).toBeTruthy();
 502         expect(serviceId.disabled).toBeTruthy();
 503       });
 504     });
 505   });
 506 });