ui/code-owners-service_test.html - plugins/code-owners - Git at Google

 <!DOCTYPE html>
 <meta name="viewport" content="width=device-width, minimum-scale=1.0, initial-scale=1.0, user-scalable=yes">

 <script src="/node_modules/@webcomponents/webcomponentsjs/custom-elements-es5-adapter.js"></script>
 <script src="../node_modules/@webcomponents/webcomponentsjs/webcomponents-loader.js"></script>
 <script src="../bower_components/web-component-tester/browser.js"></script>

 <title>code owners service test</title>

 <script type="module">
   import '../test/common-test-setup.js';
   import {CodeOwnerService} from './code-owners-service.js';

   suite('code owners service tests', () => {
     let sandbox;
     let codeOwnersService;
     const fakeRestApi = {
       get() {
         return Promise.resolve({});
       },
       getLoggedIn() {
         return Promise.resolve(undefined);
       },
     };
     const getApiStub = sinon.stub(fakeRestApi, 'get');
     getApiStub.returns(Promise.resolve({}));
     const fakeStatus = {
       // fake data with fake files
       patch_set_number: 1,
       file_code_owner_statuses: [
         {
           new_path_status: {
             path: 'a.js',
             status: 'INSUFFICIENT_REVIEWERS',
           },
         },
         {
           new_path_status: {
             path: 'b.js',
             status: 'INSUFFICIENT_REVIEWERS',
           },
         },
         {
           new_path_status: {
             path: 'c.ts',
             status: 'INSUFFICIENT_REVIEWERS',
           },
         },
         {
           change_type: 'RENAMED',
           old_path_status: {
             path: 'd.ts',
             status: 'INSUFFICIENT_REVIEWERS',
           },
           new_path_status: {
             path: 'd_edit.ts',
             status: 'INSUFFICIENT_REVIEWERS',
           },
         },
         {
           new_path_status: {
             path: 'e.ts',
             status: 'PENDING',
           },
         },
         {
           new_path_status: {
             path: 'f.ts',
             status: 'PENDING',
           },
         },
         {
           new_path_status: {
             path: 'g.ts',
             status: 'PENDING',
           },
         },
       ],
     };
     const fakeChange = {
       project: 'test',
       branch: 'main',
       _number: '123',
       revisions: {
         a: {
           _number: 1,
         },
       },
       current_revision: 'a',
     };

     setup(() => {
       sandbox = sinon.sandbox.create();
       getApiStub.reset();
     });

     teardown(() => { sandbox.restore(); });

     suite('basic api request tests', () => {
       setup(done => {
         getApiStub.withArgs(`/changes/${fakeChange._number}/code_owners.status`)
             .returns(Promise.resolve(fakeStatus));
         codeOwnersService = CodeOwnerService.getOwnerService(fakeRestApi,
             {...fakeChange});
         flush(done);
       });

       test('getOwnerService - same change returns the same instance', () => {
         assert.equal(
             CodeOwnerService.getOwnerService(fakeRestApi, fakeChange),
             CodeOwnerService.getOwnerService(fakeRestApi, fakeChange)
         );
       });

       test('return a new instance when change changed', () => {
         assert.notEqual(
             CodeOwnerService.getOwnerService(fakeRestApi, {...fakeChange}),
             CodeOwnerService.getOwnerService(fakeRestApi, {...fakeChange})
         );
       });

       test('should fetch status after init', () => {
         assert.isTrue(getApiStub.calledOnce);
         assert.equal(getApiStub.lastCall.args[0],
             `/changes/${fakeChange._number}/code_owners.status`);
       });

       test('getSuggestion should kickoff the fetch', done => {
         codeOwnersService.getSuggestedOwners().then(r => {
           // 6 requests for getting file owners + 1 status call
           assert.equal(getApiStub.callCount, 7);
           assert.equal(r.finished, false);
           flush(() => {
             assert.equal(getApiStub.callCount, 9);
             done();
           });
         });
       });

       test('approved status calculation', done => {
         codeOwnersService.areAllFilesApproved().then(approved => {
           assert.equal(approved, false);
           done();
         });
       });
     });

     suite('all approved case', () => {
       setup(done => {
         getApiStub.withArgs(`/changes/${fakeChange._number}/code_owners.status`)
             .returns(Promise.resolve({
               // fake data with fake files
               patch_set_number: 1,
               file_code_owner_statuses: [
                 {
                   new_path_status: {
                     path: 'a.js',
                     status: 'APPROVED',
                   },
                 },
                 {
                   new_path_status: {
                     path: 'b.js',
                     status: 'APPROVED',
                   },
                 },
                 {
                   old_path_status: {
                     path: 'd.js',
                     status: 'APPROVED',
                   },
                   change_type: 'DELETED',
                 },
               ],
             }));

         codeOwnersService = CodeOwnerService.getOwnerService(fakeRestApi,
             {...fakeChange});
         flush(done);
       });

       test('getSuggestion and finished in first batch', done => {
         codeOwnersService.getSuggestedOwners().then(r => {
           // 1 status call
           assert.equal(getApiStub.callCount, 1);
           // initially false as getSuggestedOwners is synchrously
           assert.equal(r.finished, false);
           codeOwnersService.getSuggestedOwners().then(nR => {
             assert.equal(nR.finished, true);
             done();
           });
         });
       });

       test('approved status calculation', done => {
         codeOwnersService.areAllFilesApproved().then(approved => {
           assert.equal(approved, true);
           done();
         });
       });
     });

     suite('abort', () => {
       setup(done => {
         getApiStub.withArgs(`/changes/${fakeChange._number}/code_owners.status`)
             .returns(Promise.resolve(fakeStatus));

         codeOwnersService = CodeOwnerService.getOwnerService(fakeRestApi,
             {...fakeChange});
         flush(done);
       });

       test('abort should abort pending requests', done => {
         codeOwnersService.getSuggestedOwners().then(r => {
           // 6 requests for getting file owners + 1 status call
           assert.equal(getApiStub.callCount, 7);
           assert.equal(r.finished, false);
           codeOwnersService.abort();
           flush(() => {
             // should still at 7 since aborted
             assert.equal(getApiStub.callCount, 7);
             done();
           });
         });
       });

       test('getSuggestedOwners should restart if aborted', done => {
         codeOwnersService.abort();
         codeOwnersService.getSuggestedOwners().then(r => {
           // 6 requests for getting file owners + 1 status call
           assert.equal(getApiStub.callCount, 7);
           assert.equal(r.finished, false);
           codeOwnersService.abort();
           flush(() => {
             codeOwnersService.getSuggestedOwners().then(r => {
               // should at 13 since restarted
               assert.equal(getApiStub.callCount, 13);
               done();
             });
           });
         });
       });
     });
   });
 </script>
	<!DOCTYPE html>
	<meta name="viewport" content="width=device-width, minimum-scale=1.0, initial-scale=1.0, user-scalable=yes">

	<script src="/node_modules/@webcomponents/webcomponentsjs/custom-elements-es5-adapter.js"></script>
	<script src="../node_modules/@webcomponents/webcomponentsjs/webcomponents-loader.js"></script>
	<script src="../bower_components/web-component-tester/browser.js"></script>

	<title>code owners service test</title>

	<script type="module">
	import '../test/common-test-setup.js';
	import {CodeOwnerService} from './code-owners-service.js';

	suite('code owners service tests', () => {
	let sandbox;
	let codeOwnersService;
	const fakeRestApi = {
	get() {
	return Promise.resolve({});
	},
	getLoggedIn() {
	return Promise.resolve(undefined);
	},
	};
	const getApiStub = sinon.stub(fakeRestApi, 'get');
	getApiStub.returns(Promise.resolve({}));
	const fakeStatus = {
	// fake data with fake files
	patch_set_number: 1,
	file_code_owner_statuses: [
	{
	new_path_status: {
	path: 'a.js',
	status: 'INSUFFICIENT_REVIEWERS',
	},
	},
	{
	new_path_status: {
	path: 'b.js',
	status: 'INSUFFICIENT_REVIEWERS',
	},
	},
	{
	new_path_status: {
	path: 'c.ts',
	status: 'INSUFFICIENT_REVIEWERS',
	},
	},
	{
	change_type: 'RENAMED',
	old_path_status: {
	path: 'd.ts',
	status: 'INSUFFICIENT_REVIEWERS',
	},
	new_path_status: {
	path: 'd_edit.ts',
	status: 'INSUFFICIENT_REVIEWERS',
	},
	},
	{
	new_path_status: {
	path: 'e.ts',
	status: 'PENDING',
	},
	},
	{
	new_path_status: {
	path: 'f.ts',
	status: 'PENDING',
	},
	},
	{
	new_path_status: {
	path: 'g.ts',
	status: 'PENDING',
	},
	},
	],
	};
	const fakeChange = {
	project: 'test',
	branch: 'main',
	_number: '123',
	revisions: {
	a: {
	_number: 1,
	},
	},
	current_revision: 'a',
	};

	setup(() => {
	sandbox = sinon.sandbox.create();
	getApiStub.reset();
	});

	teardown(() => { sandbox.restore(); });

	suite('basic api request tests', () => {
	setup(done => {
	getApiStub.withArgs(`/changes/${fakeChange._number}/code_owners.status`)
	.returns(Promise.resolve(fakeStatus));
	codeOwnersService = CodeOwnerService.getOwnerService(fakeRestApi,
	{...fakeChange});
	flush(done);
	});

	test('getOwnerService - same change returns the same instance', () => {
	assert.equal(
	CodeOwnerService.getOwnerService(fakeRestApi, fakeChange),
	CodeOwnerService.getOwnerService(fakeRestApi, fakeChange)
	);
	});

	test('return a new instance when change changed', () => {
	assert.notEqual(
	CodeOwnerService.getOwnerService(fakeRestApi, {...fakeChange}),
	CodeOwnerService.getOwnerService(fakeRestApi, {...fakeChange})
	);
	});

	test('should fetch status after init', () => {
	assert.isTrue(getApiStub.calledOnce);
	assert.equal(getApiStub.lastCall.args[0],
	`/changes/${fakeChange._number}/code_owners.status`);
	});

	test('getSuggestion should kickoff the fetch', done => {
	codeOwnersService.getSuggestedOwners().then(r => {
	// 6 requests for getting file owners + 1 status call
	assert.equal(getApiStub.callCount, 7);
	assert.equal(r.finished, false);
	flush(() => {
	assert.equal(getApiStub.callCount, 9);
	done();
	});
	});
	});

	test('approved status calculation', done => {
	codeOwnersService.areAllFilesApproved().then(approved => {
	assert.equal(approved, false);
	done();
	});
	});
	});

	suite('all approved case', () => {
	setup(done => {
	getApiStub.withArgs(`/changes/${fakeChange._number}/code_owners.status`)
	.returns(Promise.resolve({
	// fake data with fake files
	patch_set_number: 1,
	file_code_owner_statuses: [
	{
	new_path_status: {
	path: 'a.js',
	status: 'APPROVED',
	},
	},
	{
	new_path_status: {
	path: 'b.js',
	status: 'APPROVED',
	},
	},
	{
	old_path_status: {
	path: 'd.js',
	status: 'APPROVED',
	},
	change_type: 'DELETED',
	},
	],
	}));

	codeOwnersService = CodeOwnerService.getOwnerService(fakeRestApi,
	{...fakeChange});
	flush(done);
	});

	test('getSuggestion and finished in first batch', done => {
	codeOwnersService.getSuggestedOwners().then(r => {
	// 1 status call
	assert.equal(getApiStub.callCount, 1);
	// initially false as getSuggestedOwners is synchrously
	assert.equal(r.finished, false);
	codeOwnersService.getSuggestedOwners().then(nR => {
	assert.equal(nR.finished, true);
	done();
	});
	});
	});

	test('approved status calculation', done => {
	codeOwnersService.areAllFilesApproved().then(approved => {
	assert.equal(approved, true);
	done();
	});
	});
	});

	suite('abort', () => {
	setup(done => {
	getApiStub.withArgs(`/changes/${fakeChange._number}/code_owners.status`)
	.returns(Promise.resolve(fakeStatus));

	codeOwnersService = CodeOwnerService.getOwnerService(fakeRestApi,
	{...fakeChange});
	flush(done);
	});

	test('abort should abort pending requests', done => {
	codeOwnersService.getSuggestedOwners().then(r => {
	// 6 requests for getting file owners + 1 status call
	assert.equal(getApiStub.callCount, 7);
	assert.equal(r.finished, false);
	codeOwnersService.abort();
	flush(() => {
	// should still at 7 since aborted
	assert.equal(getApiStub.callCount, 7);
	done();
	});
	});
	});

	test('getSuggestedOwners should restart if aborted', done => {
	codeOwnersService.abort();
	codeOwnersService.getSuggestedOwners().then(r => {
	// 6 requests for getting file owners + 1 status call
	assert.equal(getApiStub.callCount, 7);
	assert.equal(r.finished, false);
	codeOwnersService.abort();
	flush(() => {
	codeOwnersService.getSuggestedOwners().then(r => {
	// should at 13 since restarted
	assert.equal(getApiStub.callCount, 13);
	done();
	});
	});
	});
	});
	});
	});
	</script>