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         component.onSubmit();
 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         component.onSubmit();
 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         component.onSubmit();
 353         formHelper.expectError('api_port', 'min');
 354       });
 355
 356       it('should submit invalid iscsi port (2)', () => {
 357         formHelper.setValue('api_port', 65536);
 358         component.onSubmit();
 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
 369     describe('should test service ingress', () => {
 370       beforeEach(() => {
 371         formHelper.setValue('service_type', 'ingress');
 372         formHelper.setValue('backend_service', 'rgw.foo');
 373         formHelper.setValue('virtual_ip', '192.168.20.1/24');
 374         formHelper.setValue('ssl', false);
 375       });
 376
 377       it('should submit ingress', () => {
 378         component.onSubmit();
 379         expect(cephServiceService.create).toHaveBeenCalledWith({
 380           service_type: 'ingress',
 381           placement: {},
 382           unmanaged: false,
 383           backend_service: 'rgw.foo',
 384           service_id: 'rgw.foo',
 385           virtual_ip: '192.168.20.1/24',
 386           virtual_interface_networks: null,
 387           ssl: false
 388         });
 389       });
 390
 391       it('should pre-populate the service id', () => {
 392         component.prePopulateId();
 393         const prePopulatedID = component.serviceForm.getValue('service_id');
 394         expect(prePopulatedID).toBe('rgw.foo');
 395       });
 396
 397       it('should submit valid frontend and monitor port', () => {
 398         // min value
 399         formHelper.setValue('frontend_port', 1);
 400         formHelper.setValue('monitor_port', 1);
 401         component.onSubmit();
 402         formHelper.expectValid('frontend_port');
 403         formHelper.expectValid('monitor_port');
 404
 405         // max value
 406         formHelper.setValue('frontend_port', 65535);
 407         formHelper.setValue('monitor_port', 65535);
 408         component.onSubmit();
 409         formHelper.expectValid('frontend_port');
 410         formHelper.expectValid('monitor_port');
 411       });
 412
 413       it('should submit invalid frontend and monitor port', () => {
 414         // min
 415         formHelper.setValue('frontend_port', 0);
 416         formHelper.setValue('monitor_port', 0);
 417         component.onSubmit();
 418         formHelper.expectError('frontend_port', 'min');
 419         formHelper.expectError('monitor_port', 'min');
 420
 421         // max
 422         formHelper.setValue('frontend_port', 65536);
 423         formHelper.setValue('monitor_port', 65536);
 424         component.onSubmit();
 425         formHelper.expectError('frontend_port', 'max');
 426         formHelper.expectError('monitor_port', 'max');
 427
 428         // pattern
 429         formHelper.setValue('frontend_port', 'abc');
 430         formHelper.setValue('monitor_port', 'abc');
 431         component.onSubmit();
 432         formHelper.expectError('frontend_port', 'pattern');
 433         formHelper.expectError('monitor_port', 'pattern');
 434       });
 435     });
 436
 437     describe('check edit fields', () => {
 438       beforeEach(() => {
 439         component.editing = true;
 440       });
 441
 442       it('should check whether edit field is correctly loaded', () => {
 443         const cephServiceSpy = spyOn(cephServiceService, 'list').and.callThrough();
 444         component.ngOnInit();
 445         expect(cephServiceSpy).toBeCalledTimes(2);
 446         expect(component.action).toBe('Edit');
 447         const serviceType = fixture.debugElement.query(By.css('#service_type')).nativeElement;
 448         const serviceId = fixture.debugElement.query(By.css('#service_id')).nativeElement;
 449         expect(serviceType.disabled).toBeTruthy();
 450         expect(serviceId.disabled).toBeTruthy();
 451       });
 452     });
 453   });
 454 });