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 { 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     imports: [
  27       HttpClientTestingModule,
  28       NgbTypeaheadModule,
  29       ReactiveFormsModule,
  30       RouterTestingModule,
  31       SharedModule,
  32       ToastrModule.forRoot()
  33     ]
  34   });
  35
  36   beforeEach(() => {
  37     fixture = TestBed.createComponent(ServiceFormComponent);
  38     component = fixture.componentInstance;
  39     form = component.serviceForm;
  40     formHelper = new FormHelper(form);
  41     fixture.detectChanges();
  42   });
  43
  44   it('should create', () => {
  45     expect(component).toBeTruthy();
  46   });
  47
  48   describe('should test form', () => {
  49     beforeEach(() => {
  50       cephServiceService = TestBed.inject(CephServiceService);
  51       spyOn(cephServiceService, 'create').and.stub();
  52     });
  53
  54     it('should test placement (host)', () => {
  55       formHelper.setValue('service_type', 'crash');
  56       formHelper.setValue('placement', 'hosts');
  57       formHelper.setValue('hosts', ['mgr0', 'mon0', 'osd0']);
  58       formHelper.setValue('count', 2);
  59       component.onSubmit();
  60       expect(cephServiceService.create).toHaveBeenCalledWith({
  61         service_type: 'crash',
  62         placement: {
  63           hosts: ['mgr0', 'mon0', 'osd0'],
  64           count: 2
  65         },
  66         unmanaged: false
  67       });
  68     });
  69
  70     it('should test placement (label)', () => {
  71       formHelper.setValue('service_type', 'mgr');
  72       formHelper.setValue('placement', 'label');
  73       formHelper.setValue('label', 'foo');
  74       component.onSubmit();
  75       expect(cephServiceService.create).toHaveBeenCalledWith({
  76         service_type: 'mgr',
  77         placement: {
  78           label: 'foo'
  79         },
  80         unmanaged: false
  81       });
  82     });
  83
  84     it('should submit valid count', () => {
  85       formHelper.setValue('count', 1);
  86       component.onSubmit();
  87       formHelper.expectValid('count');
  88     });
  89
  90     it('should submit invalid count (1)', () => {
  91       formHelper.setValue('count', 0);
  92       component.onSubmit();
  93       formHelper.expectError('count', 'min');
  94     });
  95
  96     it('should submit invalid count (2)', () => {
  97       formHelper.setValue('count', 'abc');
  98       component.onSubmit();
  99       formHelper.expectError('count', 'pattern');
 100     });
 101
 102     it('should test unmanaged', () => {
 103       formHelper.setValue('service_type', 'rgw');
 104       formHelper.setValue('placement', 'label');
 105       formHelper.setValue('label', 'bar');
 106       formHelper.setValue('rgw_frontend_port', 4567);
 107       formHelper.setValue('unmanaged', true);
 108       component.onSubmit();
 109       expect(cephServiceService.create).toHaveBeenCalledWith({
 110         service_type: 'rgw',
 111         placement: {},
 112         unmanaged: true
 113       });
 114     });
 115
 116     it('should test various services', () => {
 117       _.forEach(
 118         [
 119           'alertmanager',
 120           'crash',
 121           'grafana',
 122           'mds',
 123           'mgr',
 124           'mon',
 125           'node-exporter',
 126           'prometheus',
 127           'rbd-mirror'
 128         ],
 129         (serviceType) => {
 130           formHelper.setValue('service_type', serviceType);
 131           component.onSubmit();
 132           expect(cephServiceService.create).toHaveBeenCalledWith({
 133             service_type: serviceType,
 134             placement: {},
 135             unmanaged: false
 136           });
 137         }
 138       );
 139     });
 140
 141     describe('should test service nfs', () => {
 142       beforeEach(() => {
 143         formHelper.setValue('service_type', 'nfs');
 144         formHelper.setValue('pool', 'foo');
 145       });
 146
 147       it('should submit nfs with namespace', () => {
 148         formHelper.setValue('namespace', 'bar');
 149         component.onSubmit();
 150         expect(cephServiceService.create).toHaveBeenCalledWith({
 151           service_type: 'nfs',
 152           placement: {},
 153           unmanaged: false,
 154           pool: 'foo',
 155           namespace: 'bar'
 156         });
 157       });
 158
 159       it('should submit nfs w/o namespace', () => {
 160         component.onSubmit();
 161         expect(cephServiceService.create).toHaveBeenCalledWith({
 162           service_type: 'nfs',
 163           placement: {},
 164           unmanaged: false,
 165           pool: 'foo'
 166         });
 167       });
 168     });
 169
 170     describe('should test service rgw', () => {
 171       beforeEach(() => {
 172         formHelper.setValue('service_type', 'rgw');
 173       });
 174
 175       it('should test rgw valid service id', () => {
 176         formHelper.setValue('service_id', 'foo.bar');
 177         formHelper.expectValid('service_id');
 178         formHelper.setValue('service_id', 'foo.bar.bas');
 179         formHelper.expectValid('service_id');
 180       });
 181
 182       it('should test rgw invalid service id', () => {
 183         formHelper.setValue('service_id', 'foo');
 184         formHelper.expectError('service_id', 'rgwPattern');
 185         formHelper.setValue('service_id', 'foo.');
 186         formHelper.expectError('service_id', 'rgwPattern');
 187         formHelper.setValue('service_id', 'foo.bar.');
 188         formHelper.expectError('service_id', 'rgwPattern');
 189         formHelper.setValue('service_id', 'foo.bar.bas.');
 190         formHelper.expectError('service_id', 'rgwPattern');
 191       });
 192
 193       it('should submit rgw with port', () => {
 194         formHelper.setValue('rgw_frontend_port', 1234);
 195         formHelper.setValue('ssl', true);
 196         component.onSubmit();
 197         expect(cephServiceService.create).toHaveBeenCalledWith({
 198           service_type: 'rgw',
 199           placement: {},
 200           unmanaged: false,
 201           rgw_frontend_port: 1234,
 202           rgw_frontend_ssl_certificate: '',
 203           ssl: true
 204         });
 205       });
 206
 207       it('should submit valid rgw port (1)', () => {
 208         formHelper.setValue('rgw_frontend_port', 1);
 209         component.onSubmit();
 210         formHelper.expectValid('rgw_frontend_port');
 211       });
 212
 213       it('should submit valid rgw port (2)', () => {
 214         formHelper.setValue('rgw_frontend_port', 65535);
 215         component.onSubmit();
 216         formHelper.expectValid('rgw_frontend_port');
 217       });
 218
 219       it('should submit invalid rgw port (1)', () => {
 220         formHelper.setValue('rgw_frontend_port', 0);
 221         component.onSubmit();
 222         formHelper.expectError('rgw_frontend_port', 'min');
 223       });
 224
 225       it('should submit invalid rgw port (2)', () => {
 226         formHelper.setValue('rgw_frontend_port', 65536);
 227         component.onSubmit();
 228         formHelper.expectError('rgw_frontend_port', 'max');
 229       });
 230
 231       it('should submit invalid rgw port (3)', () => {
 232         formHelper.setValue('rgw_frontend_port', 'abc');
 233         component.onSubmit();
 234         formHelper.expectError('rgw_frontend_port', 'pattern');
 235       });
 236
 237       it('should submit rgw w/o port', () => {
 238         formHelper.setValue('ssl', false);
 239         component.onSubmit();
 240         expect(cephServiceService.create).toHaveBeenCalledWith({
 241           service_type: 'rgw',
 242           placement: {},
 243           unmanaged: false,
 244           ssl: false
 245         });
 246       });
 247
 248       it('should not show private key field', () => {
 249         formHelper.setValue('ssl', true);
 250         fixture.detectChanges();
 251         const ssl_key = fixture.debugElement.query(By.css('#ssl_key'));
 252         expect(ssl_key).toBeNull();
 253       });
 254
 255       it('should test .pem file', () => {
 256         const pemCert = `
 257 -----BEGIN CERTIFICATE-----
 258 iJ5IbgzlKPssdYwuAEI3yPZxX/g5vKBrgcyD3LttLL/DlElq/1xCnwVrv7WROSNu
 259 -----END CERTIFICATE-----
 260 -----BEGIN CERTIFICATE-----
 261 mn/S7BNBEC7AGe5ajmN+8hBTGdACUXe8rwMNrtTy/MwBZ0VpJsAAjJh+aptZh5yB
 262 -----END CERTIFICATE-----
 263 -----BEGIN RSA PRIVATE KEY-----
 264 x4Ea7kGVgx9kWh5XjWz9wjZvY49UKIT5ppIAWPMbLl3UpfckiuNhTA==
 265 -----END RSA PRIVATE KEY-----`;
 266         formHelper.setValue('ssl', true);
 267         formHelper.setValue('ssl_cert', pemCert);
 268         fixture.detectChanges();
 269         formHelper.expectValid('ssl_cert');
 270       });
 271     });
 272
 273     describe('should test service iscsi', () => {
 274       beforeEach(() => {
 275         formHelper.setValue('service_type', 'iscsi');
 276         formHelper.setValue('pool', 'xyz');
 277         formHelper.setValue('api_user', 'user');
 278         formHelper.setValue('api_password', 'password');
 279         formHelper.setValue('ssl', false);
 280       });
 281
 282       it('should submit iscsi', () => {
 283         component.onSubmit();
 284         expect(cephServiceService.create).toHaveBeenCalledWith({
 285           service_type: 'iscsi',
 286           placement: {},
 287           unmanaged: false,
 288           pool: 'xyz',
 289           api_user: 'user',
 290           api_password: 'password',
 291           api_secure: false
 292         });
 293       });
 294
 295       it('should submit iscsi with trusted ips', () => {
 296         formHelper.setValue('ssl', true);
 297         formHelper.setValue('trusted_ip_list', ' 172.16.0.5, 192.1.1.10  ');
 298         component.onSubmit();
 299         expect(cephServiceService.create).toHaveBeenCalledWith({
 300           service_type: 'iscsi',
 301           placement: {},
 302           unmanaged: false,
 303           pool: 'xyz',
 304           api_user: 'user',
 305           api_password: 'password',
 306           api_secure: true,
 307           ssl_cert: '',
 308           ssl_key: '',
 309           trusted_ip_list: '172.16.0.5, 192.1.1.10'
 310         });
 311       });
 312
 313       it('should submit iscsi with port', () => {
 314         formHelper.setValue('api_port', 456);
 315         component.onSubmit();
 316         expect(cephServiceService.create).toHaveBeenCalledWith({
 317           service_type: 'iscsi',
 318           placement: {},
 319           unmanaged: false,
 320           pool: 'xyz',
 321           api_user: 'user',
 322           api_password: 'password',
 323           api_secure: false,
 324           api_port: 456
 325         });
 326       });
 327
 328       it('should submit valid iscsi port (1)', () => {
 329         formHelper.setValue('api_port', 1);
 330         component.onSubmit();
 331         formHelper.expectValid('api_port');
 332       });
 333
 334       it('should submit valid iscsi port (2)', () => {
 335         formHelper.setValue('api_port', 65535);
 336         component.onSubmit();
 337         formHelper.expectValid('api_port');
 338       });
 339
 340       it('should submit invalid iscsi port (1)', () => {
 341         formHelper.setValue('api_port', 0);
 342         component.onSubmit();
 343         formHelper.expectError('api_port', 'min');
 344       });
 345
 346       it('should submit invalid iscsi port (2)', () => {
 347         formHelper.setValue('api_port', 65536);
 348         component.onSubmit();
 349         formHelper.expectError('api_port', 'max');
 350       });
 351
 352       it('should submit invalid iscsi port (3)', () => {
 353         formHelper.setValue('api_port', 'abc');
 354         component.onSubmit();
 355         formHelper.expectError('api_port', 'pattern');
 356       });
 357     });
 358
 359     describe('should test service ingress', () => {
 360       beforeEach(() => {
 361         formHelper.setValue('service_type', 'ingress');
 362         formHelper.setValue('backend_service', 'rgw.foo');
 363         formHelper.setValue('virtual_ip', '192.168.20.1/24');
 364         formHelper.setValue('ssl', false);
 365       });
 366
 367       it('should submit ingress', () => {
 368         component.onSubmit();
 369         expect(cephServiceService.create).toHaveBeenCalledWith({
 370           service_type: 'ingress',
 371           placement: {},
 372           unmanaged: false,
 373           backend_service: 'rgw.foo',
 374           service_id: 'rgw.foo',
 375           virtual_ip: '192.168.20.1/24',
 376           virtual_interface_networks: null,
 377           ssl: false
 378         });
 379       });
 380
 381       it('should pre-populate the service id', () => {
 382         component.prePopulateId();
 383         const prePopulatedID = component.serviceForm.getValue('service_id');
 384         expect(prePopulatedID).toBe('rgw.foo');
 385       });
 386
 387       it('should submit valid frontend and monitor port', () => {
 388         // min value
 389         formHelper.setValue('frontend_port', 1);
 390         formHelper.setValue('monitor_port', 1);
 391         component.onSubmit();
 392         formHelper.expectValid('frontend_port');
 393         formHelper.expectValid('monitor_port');
 394
 395         // max value
 396         formHelper.setValue('frontend_port', 65535);
 397         formHelper.setValue('monitor_port', 65535);
 398         component.onSubmit();
 399         formHelper.expectValid('frontend_port');
 400         formHelper.expectValid('monitor_port');
 401       });
 402
 403       it('should submit invalid frontend and monitor port', () => {
 404         // min
 405         formHelper.setValue('frontend_port', 0);
 406         formHelper.setValue('monitor_port', 0);
 407         component.onSubmit();
 408         formHelper.expectError('frontend_port', 'min');
 409         formHelper.expectError('monitor_port', 'min');
 410
 411         // max
 412         formHelper.setValue('frontend_port', 65536);
 413         formHelper.setValue('monitor_port', 65536);
 414         component.onSubmit();
 415         formHelper.expectError('frontend_port', 'max');
 416         formHelper.expectError('monitor_port', 'max');
 417
 418         // pattern
 419         formHelper.setValue('frontend_port', 'abc');
 420         formHelper.setValue('monitor_port', 'abc');
 421         component.onSubmit();
 422         formHelper.expectError('frontend_port', 'pattern');
 423         formHelper.expectError('monitor_port', 'pattern');
 424       });
 425     });
 426   });
 427 });