git.apps.os.sepia.ceph.com Git - ceph-ci.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
 256     describe('should test service iscsi', () => {
 257       beforeEach(() => {
 258         formHelper.setValue('service_type', 'iscsi');
 259         formHelper.setValue('pool', 'xyz');
 260         formHelper.setValue('api_user', 'user');
 261         formHelper.setValue('api_password', 'password');
 262         formHelper.setValue('ssl', false);
 263       });
 264
 265       it('should submit iscsi', () => {
 266         component.onSubmit();
 267         expect(cephServiceService.create).toHaveBeenCalledWith({
 268           service_type: 'iscsi',
 269           placement: {},
 270           unmanaged: false,
 271           pool: 'xyz',
 272           api_user: 'user',
 273           api_password: 'password',
 274           api_secure: false
 275         });
 276       });
 277
 278       it('should submit iscsi with trusted ips', () => {
 279         formHelper.setValue('ssl', true);
 280         formHelper.setValue('trusted_ip_list', ' 172.16.0.5, 192.1.1.10  ');
 281         component.onSubmit();
 282         expect(cephServiceService.create).toHaveBeenCalledWith({
 283           service_type: 'iscsi',
 284           placement: {},
 285           unmanaged: false,
 286           pool: 'xyz',
 287           api_user: 'user',
 288           api_password: 'password',
 289           api_secure: true,
 290           ssl_cert: '',
 291           ssl_key: '',
 292           trusted_ip_list: '172.16.0.5, 192.1.1.10'
 293         });
 294       });
 295
 296       it('should submit iscsi with port', () => {
 297         formHelper.setValue('api_port', 456);
 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: false,
 307           api_port: 456
 308         });
 309       });
 310
 311       it('should submit valid iscsi port (1)', () => {
 312         formHelper.setValue('api_port', 1);
 313         component.onSubmit();
 314         formHelper.expectValid('api_port');
 315       });
 316
 317       it('should submit valid iscsi port (2)', () => {
 318         formHelper.setValue('api_port', 65535);
 319         component.onSubmit();
 320         formHelper.expectValid('api_port');
 321       });
 322
 323       it('should submit invalid iscsi port (1)', () => {
 324         formHelper.setValue('api_port', 0);
 325         component.onSubmit();
 326         formHelper.expectError('api_port', 'min');
 327       });
 328
 329       it('should submit invalid iscsi port (2)', () => {
 330         formHelper.setValue('api_port', 65536);
 331         component.onSubmit();
 332         formHelper.expectError('api_port', 'max');
 333       });
 334
 335       it('should submit invalid iscsi port (3)', () => {
 336         formHelper.setValue('api_port', 'abc');
 337         component.onSubmit();
 338         formHelper.expectError('api_port', 'pattern');
 339       });
 340     });
 341
 342     describe('should test service ingress', () => {
 343       beforeEach(() => {
 344         formHelper.setValue('service_type', 'ingress');
 345         formHelper.setValue('backend_service', 'rgw.foo');
 346         formHelper.setValue('virtual_ip', '192.168.20.1/24');
 347         formHelper.setValue('ssl', false);
 348       });
 349
 350       it('should submit ingress', () => {
 351         component.onSubmit();
 352         expect(cephServiceService.create).toHaveBeenCalledWith({
 353           service_type: 'ingress',
 354           placement: {},
 355           unmanaged: false,
 356           backend_service: 'rgw.foo',
 357           service_id: 'rgw.foo',
 358           virtual_ip: '192.168.20.1/24',
 359           virtual_interface_networks: null,
 360           ssl: false
 361         });
 362       });
 363
 364       it('should pre-populate the service id', () => {
 365         component.prePopulateId();
 366         const prePopulatedID = component.serviceForm.getValue('service_id');
 367         expect(prePopulatedID).toBe('rgw.foo');
 368       });
 369
 370       it('should submit valid frontend and monitor port', () => {
 371         // min value
 372         formHelper.setValue('frontend_port', 1);
 373         formHelper.setValue('monitor_port', 1);
 374         component.onSubmit();
 375         formHelper.expectValid('frontend_port');
 376         formHelper.expectValid('monitor_port');
 377
 378         // max value
 379         formHelper.setValue('frontend_port', 65535);
 380         formHelper.setValue('monitor_port', 65535);
 381         component.onSubmit();
 382         formHelper.expectValid('frontend_port');
 383         formHelper.expectValid('monitor_port');
 384       });
 385
 386       it('should submit invalid frontend and monitor port', () => {
 387         // min
 388         formHelper.setValue('frontend_port', 0);
 389         formHelper.setValue('monitor_port', 0);
 390         component.onSubmit();
 391         formHelper.expectError('frontend_port', 'min');
 392         formHelper.expectError('monitor_port', 'min');
 393
 394         // max
 395         formHelper.setValue('frontend_port', 65536);
 396         formHelper.setValue('monitor_port', 65536);
 397         component.onSubmit();
 398         formHelper.expectError('frontend_port', 'max');
 399         formHelper.expectError('monitor_port', 'max');
 400
 401         // pattern
 402         formHelper.setValue('frontend_port', 'abc');
 403         formHelper.setValue('monitor_port', 'abc');
 404         component.onSubmit();
 405         formHelper.expectError('frontend_port', 'pattern');
 406         formHelper.expectError('monitor_port', 'pattern');
 407       });
 408     });
 409   });
 410 });