FOSSology  4.7.1
Open Source License Compliance by Open Source Software
CopyrightControllerTest.php
Go to the documentation of this file.
1 <?php
2 /*
3  SPDX-FileCopyrightText: © 2022 Valens Niyonsenga <valensniyonsenga2003@gmail.com>
4 
5  SPDX-License-Identifier: GPL-2.0-only
6 */
7 
13 namespace Fossology\UI\Api\Test\Controllers;
14 
15 use Fossology\Lib\Auth\Auth;
16 use Fossology\Lib\Dao\CopyrightDao;
17 use Fossology\Lib\Dao\UploadDao;
18 use Fossology\Lib\Dao\UserDao;
19 use Fossology\UI\Api\Controllers\CopyrightController;
20 use Fossology\UI\Api\Exceptions\HttpBadRequestException;
21 use Fossology\UI\Api\Exceptions\HttpNotFoundException;
22 use Fossology\UI\Api\Helper\DbHelper;
23 use Fossology\UI\Api\Helper\ResponseHelper;
24 use Fossology\UI\Api\Helper\RestHelper;
25 use Fossology\UI\Api\Models\Info;
26 use Fossology\UI\Api\Models\InfoType;
27 use Mockery as M;
28 use Slim\Psr7\Request;
29 use Slim\Psr7\Uri;
30 use Slim\Psr7\Factory\StreamFactory;
31 use Slim\Psr7\Headers;
32 
33 /*
34  SPDX-FileCopyrightText: © 2022 Valens Niyonsenga <valensniyonsenga2003@gmail.com>
35 
36  SPDX-License-Identifier: GPL-2.0-only
37 */
38 class CopyrightControllerTest extends \PHPUnit\Framework\TestCase
39 {
44  private $dbHelper;
45 
50  private $restHelper;
51 
56  private $copyrightDao;
61  private $uploadDao;
62 
68  private $copyrightController;
74  private $copyrightHist;
79  private $streamFactory;
80 
85  public function setUp(): void
86  {
87  global $container;
88  $container = M::mock('ContainerBuilder');
89  $this->dbHelper = M::mock(DbHelper::class);
90  $this->restHelper = M::mock(RestHelper::class);
91  $this->userDao = M::mock(UserDao::class);
92  $this->uploadDao = M::mock(UploadDao::class);
93  $this->auth = M::mock(Auth::class);
94  $this->copyrightDao = M::mock(CopyrightDao::class);
95  $this->copyrightHist = M::mock('CopyrightHistogramProcessPost');
96 
97  $this->restHelper->shouldReceive('getDbHelper')->andReturn($this->dbHelper);
98  $this->restHelper->shouldReceive('getPlugin')
99  ->withArgs(['ajax-copyright-hist'])->andReturn($this->copyrightHist);
100  $this->restHelper->shouldReceive('getUploadDao')
101  ->andReturn($this->uploadDao);
102  $container->shouldReceive('get')->withArgs(array(
103  'helper.restHelper'))->andReturn($this->restHelper);
104  $container->shouldReceive('get')->withArgs(array(
105  'dao.copyright'
106  ))->andReturn($this->copyrightDao);
107  $this->streamFactory = new StreamFactory();
108  $this->copyrightController = new CopyrightController($container);
109  }
110 
117  private function getResponseJson($response)
118  {
119  $response->getBody()->seek(0);
120  return json_decode($response->getBody()->getContents(), true);
121  }
127  public function testGetTotalFileCopyrightsUploadNotFound()
128  {
129  $args = [
130  "id" => 4,
131  "itemId" => 2,
132  ];
133  $this->dbHelper->shouldReceive("doesIdExist")
134  ->withArgs(['upload','upload_pk', $args['id']])->andReturn(false);
135  $requestHeaders = new Headers();
136  $body = $this->streamFactory->createStream();
137  $request = new Request("GET", new Uri("HTTP", "localhost"),
138  $requestHeaders, [], [], $body);
139  $request = $request->withQueryParams([]);
140  $this->expectException(HttpNotFoundException::class);
141  $this->copyrightController->getTotalFileCopyrights($request, new ResponseHelper(),$args);
142  }
143 
149  public function testGetTotalFileCopyrightsItemNotFound()
150  {
151  $args = [
152  "id" => 4,
153  "itemId" => 2,
154  ];
155  $this->dbHelper->shouldReceive("doesIdExist")
156  ->withArgs(['upload','upload_pk', $args['id']])->andReturn(true);
157  $this->uploadDao->shouldReceive("getUploadtreeTableName")
158  ->withArgs([$args['id']])->andReturn("uploadtree");
159  $this->restHelper->shouldReceive("getGroupId")
160  ->andReturn(4);
161  $this->uploadDao->shouldReceive("isAccessible")
162  ->withArgs([$args['id'],4])->andReturn(true);
163  $this->uploadDao->shouldReceive("getUploadEntry")
164  ->withArgs([$args['itemId'], 'uploadtree'])
165  ->andReturn(false);
166 
167  $requestHeaders = new Headers();
168  $body = $this->streamFactory->createStream();
169  $request = new Request("GET", new Uri("HTTP", "localhost"),
170  $requestHeaders, [], [], $body);
171  $request = $request->withQueryParams([]);
172  $this->expectException(HttpNotFoundException::class);
173  $this->copyrightController->getTotalFileCopyrights($request, new ResponseHelper(),$args);
174  }
175 
176 
182  public function testGetTotalFileCopyrightsWithBadRequest()
183  {
184  $args = [
185  "id" => 4,
186  "itemId" => 2,
187  ];
188  $this->dbHelper->shouldReceive("doesIdExist")
189  ->withArgs(['upload','upload_pk', $args['id']])->andReturn(true);
190  $this->uploadDao->shouldReceive("getUploadtreeTableName")
191  ->withArgs([$args['id']])->andReturn("uploadtree");
192  $this->restHelper->shouldReceive("getGroupId")
193  ->andReturn(4);
194  $this->uploadDao->shouldReceive("isAccessible")
195  ->withArgs([$args['id'],4])->andReturn(true);
196  $this->uploadDao->shouldReceive("getUploadEntry")
197  ->withArgs([$args['itemId'], 'uploadtree'])
198  ->andReturn(['upload_fk' => (string) $args['id']]);
199 
200  $requestHeaders = new Headers();
201  $body = $this->streamFactory->createStream();
202  $request = new Request("GET", new Uri("HTTP", "localhost"),
203  $requestHeaders, [], [], $body);
204  $request = $request->withQueryParams([]);
205  $this->expectException(HttpBadRequestException::class);
206  $this->copyrightController->getTotalFileCopyrights($request, new ResponseHelper(),$args);
207  }
208 
209 
216  public function testGetTotalFileCopyrightsWithInvalidQueryParams()
217  {
218  $args = [
219  "id" => 4,
220  "itemId" => 2,
221  ];
222  $this->dbHelper->shouldReceive("doesIdExist")
223  ->withArgs(['upload','upload_pk', $args['id']])->andReturn(true);
224  $this->uploadDao->shouldReceive("getUploadtreeTableName")
225  ->withArgs([$args['id']])->andReturn("uploadtree");
226  $this->restHelper->shouldReceive("getGroupId")
227  ->andReturn(4);
228  $this->uploadDao->shouldReceive("isAccessible")
229  ->withArgs([$args['id'],4])->andReturn(true);
230  $this->uploadDao->shouldReceive("getUploadEntry")
231  ->withArgs([$args['itemId'], 'uploadtree'])
232  ->andReturn(['upload_fk' => (string) $args['id']]);
233  $this->copyrightHist->shouldReceive('getAgentId')
234  ->withArgs([$args['id'],'copyright_ars'])->andReturn(1);
235  $this->copyrightDao->shouldReceive('getTotalCopyrights')
236  ->withArgs([$args['id'],4,'uploadtree',3])->andReturn(10);
237 
238  $requestHeaders = new Headers();
239  $body = $this->streamFactory->createStream();
240  $request = new Request("GET", new Uri("HTTP", "localhost"),
241  $requestHeaders, [], [], $body);
242  $request = $request->withQueryParams(["status" => "invalid"]);
243  $this->expectException(HttpBadRequestException::class);
244 
245  $expectedResponse = (new ResponseHelper())->withJson(array('total_copyrights' => 10));
246  $actualResponse = $this->copyrightController->getTotalFileCopyrights($request, new ResponseHelper(),$args);
247  $this->assertEquals($expectedResponse, $actualResponse);
248  $this->assertEquals($this->getResponseJson($expectedResponse), $this->getResponseJson($actualResponse));
249  $this->assertEquals(200,$actualResponse->getStatusCode());
250  }
251 
257  public function testGetFileCopyrightsWithInvalidLimit()
258  {
259  $args = [
260  "id" => 4,
261  "itemId" => 2,
262  ];
263  $requestHeaders = new Headers();
264  $requestHeaders->setHeader('limit', 0);
265  $body = $this->streamFactory->createStream();
266  $request = new Request("GET", new Uri("HTTP", "localhost"),
267  $requestHeaders, [], [], $body);
268  $request = $request->withQueryParams(["status" => "invalid"]);
269  $this->expectException(HttpBadRequestException::class);
270  $this->copyrightController->getFileCopyrights($request, new ResponseHelper(),$args);
271 
272  }
273 
274 
281  public function testGetFileCopyrights()
282  {
283  $dumRows = $this->getDummyData()['dumRows'];
284  $args = $this->getDummyData()['args'];
285 
286  $this->uploadDao->shouldReceive("getUploadtreeTableName")
287  ->withArgs([$args['id']])->andReturn("uploadtree");
288  $this->uploadDao->shouldReceive("getUploadEntry")
289  ->withArgs([$args['itemId'], 'uploadtree'])
290  ->andReturn(['upload_fk' => (string) $args['id']]);
291  $this->dbHelper->shouldReceive("doesIdExist")
292  ->withArgs(['upload','upload_pk', $args['id']])->andReturn(true);
293  $this->restHelper->shouldReceive("getGroupId")
294  ->andReturn(4);
295  $this->uploadDao->shouldReceive("isAccessible")
296  ->withArgs([$args['id'],4])->andReturn(true);
297  $this->copyrightHist->shouldReceive('getAgentId')
298  ->withArgs([$args['id'],'copyright_ars'])->andReturn(1);
299 
300  $this->copyrightHist->shouldReceive('getCopyrights')
301  ->withArgs([$args['id'],2,'uploadtree',1,'statement', 'active',true,0,100])->andReturn([$dumRows,10,10]);
302  $requestHeaders = new Headers();
303  $requestHeaders->setHeader('limit', 100);
304  $body = $this->streamFactory->createStream();
305  $request = new Request("GET", new Uri("HTTP", "localhost"),
306  $requestHeaders, [], [], $body);
307  $request = $request->withQueryParams(["status" => "active"]);
308 
309  foreach ($dumRows as $row) {
310  $row['count'] = intval($row['copyright_count']);
311  unset($row['copyright_count']);
312  $finalVal[] = $row;
313  }
314  $totalPages = intval(ceil(10/100));
315  $expectedResponse = (new ResponseHelper())->withHeader('X-Total-Pages',$totalPages)->withJson($finalVal,200);
316  $actualResponse = $this->copyrightController->getFileCopyrights($request, new ResponseHelper(),$args);
317  $this->assertEquals($this->getResponseJson($expectedResponse), $this->getResponseJson($actualResponse));
318  $this->assertEquals(200,$actualResponse->getStatusCode());
319  }
320 
326  public function testGetFileCopyrightsWithInvalidPage()
327  {
328  $args = [
329  "id" => 4,
330  "itemId" => 2,
331  ];
332 
333  $this->uploadDao->shouldReceive("getUploadtreeTableName")
334  ->withArgs([$args['id']])->andReturn("uploadtree");
335  $this->uploadDao->shouldReceive("getUploadEntry")
336  ->withArgs([$args['itemId'], 'uploadtree'])
337  ->andReturn(['upload_fk' => (string) $args['id']]);
338  $this->dbHelper->shouldReceive("doesIdExist")
339  ->withArgs(['upload','upload_pk', $args['id']])->andReturn(true);
340  $this->restHelper->shouldReceive("getGroupId")
341  ->andReturn(4);
342  $this->uploadDao->shouldReceive("isAccessible")
343  ->withArgs([$args['id'],4])->andReturn(true);
344  $this->copyrightHist->shouldReceive('getAgentId')
345  ->withArgs([$args['id'],'copyright_ars'])->andReturn(1);
346 
347  $requestHeaders = new Headers();
348  $requestHeaders->setHeader('limit', 100);
349  $requestHeaders->setHeader("page",-1);
350  $body = $this->streamFactory->createStream();
351  $request = new Request("GET", new Uri("HTTP", "localhost"),
352  $requestHeaders, [], [], $body);
353  $request = $request->withQueryParams(["status" => "active"]);
354 
355  $this->expectException(HttpBadRequestException::class);
356  $this->copyrightController->getFileCopyrights($request, new ResponseHelper(),$args);
357  }
358 
359 
360  public function getDummyData()
361  {
362  $dumRows = array(
363  array(
364  "count" => 10,
365  "copyright_count" => 10,
366  ),
367  array(
368  "count" => 15,
369  "copyright_count" => 12,
370  )
371  );
372  $args = [
373  "id" => 4,
374  "itemId" => 2,
375  ];
376  return [
377  'dumRows' => $dumRows,
378  'args' => $args,
379  ];
380  }
387  public function testGetFileEmail()
388  {
389  $dumRows = $this->getDummyData()['dumRows'];
390  $args = $this->getDummyData()['args'];
391  $this->uploadDao->shouldReceive("getUploadtreeTableName")
392  ->withArgs([$args['id']])->andReturn("uploadtree");
393  $this->uploadDao->shouldReceive("getUploadEntry")
394  ->withArgs([$args['itemId'], 'uploadtree'])
395  ->andReturn(['upload_fk' => (string) $args['id']]);
396  $this->dbHelper->shouldReceive("doesIdExist")
397  ->withArgs(['upload','upload_pk', $args['id']])->andReturn(true);
398  $this->restHelper->shouldReceive("getGroupId")
399  ->andReturn(4);
400  $this->uploadDao->shouldReceive("isAccessible")
401  ->withArgs([$args['id'],4])->andReturn(true);
402  $this->copyrightHist->shouldReceive('getAgentId')
403  ->withArgs([$args['id'],'copyright_ars'])->andReturn(1);
404 
405  $this->copyrightHist->shouldReceive('getCopyrights')
406  ->withArgs([$args['id'],2,'uploadtree',1,'email', 'active',true,0,100])->andReturn([$dumRows,10,10]);
407  $requestHeaders = new Headers();
408  $requestHeaders->setHeader('limit', 100);
409  $body = $this->streamFactory->createStream();
410  $request = new Request("GET", new Uri("HTTP", "localhost"),
411  $requestHeaders, [], [], $body);
412  $request = $request->withQueryParams(["status" => "active"]);
413 
414  foreach ($dumRows as $row) {
415  $row['count'] = intval($row['copyright_count']);
416  unset($row['copyright_count']);
417  $finalVal[] = $row;
418  }
419  $totalPages = intval(ceil(10/100));
420  $expectedResponse = (new ResponseHelper())->withHeader('X-Total-Pages',$totalPages)->withJson($finalVal,200);
421  $actualResponse = $this->copyrightController->getFileEmail($request, new ResponseHelper(),$args);
422  $this->assertEquals($this->getResponseJson($expectedResponse), $this->getResponseJson($actualResponse));
423  $this->assertEquals(200,$actualResponse->getStatusCode());
424  }
425 
426 
427 
434  public function testGetFileUrl()
435  {
436  $dumRows = $this->getDummyData()['dumRows'];
437  $args = $this->getDummyData()['args'];
438  $this->uploadDao->shouldReceive("getUploadtreeTableName")
439  ->withArgs([$args['id']])->andReturn("uploadtree");
440  $this->uploadDao->shouldReceive("getUploadEntry")
441  ->withArgs([$args['itemId'], 'uploadtree'])
442  ->andReturn(['upload_fk' => (string) $args['id']]);
443  $this->dbHelper->shouldReceive("doesIdExist")
444  ->withArgs(['upload','upload_pk', $args['id']])->andReturn(true);
445  $this->restHelper->shouldReceive("getGroupId")
446  ->andReturn(4);
447  $this->uploadDao->shouldReceive("isAccessible")
448  ->withArgs([$args['id'],4])->andReturn(true);
449  $this->copyrightHist->shouldReceive('getAgentId')
450  ->withArgs([$args['id'],'copyright_ars'])->andReturn(1);
451 
452  $this->copyrightHist->shouldReceive('getCopyrights')
453  ->withArgs([$args['id'],2,'uploadtree',1,'url', 'active',true,0,100])->andReturn([$dumRows,10,10]);
454  $requestHeaders = new Headers();
455  $requestHeaders->setHeader('limit', 100);
456  $body = $this->streamFactory->createStream();
457  $request = new Request("GET", new Uri("HTTP", "localhost"),
458  $requestHeaders, [], [], $body);
459  $request = $request->withQueryParams(["status" => "active"]);
460 
461  foreach ($dumRows as $row) {
462  $row['count'] = intval($row['copyright_count']);
463  unset($row['copyright_count']);
464  $finalVal[] = $row;
465  }
466  $totalPages = intval(ceil(10/100));
467  $expectedResponse = (new ResponseHelper())->withHeader('X-Total-Pages',$totalPages)->withJson($finalVal,200);
468  $actualResponse = $this->copyrightController->getFileUrl($request, new ResponseHelper(),$args);
469  $this->assertEquals($this->getResponseJson($expectedResponse), $this->getResponseJson($actualResponse));
470  $this->assertEquals(200,$actualResponse->getStatusCode());
471  }
472 
473 
474 
475 
482  public function testGetFileAuthor()
483  {
484  $dumRows = $this->getDummyData()['dumRows'];
485  $args = $this->getDummyData()['args'];
486  $this->uploadDao->shouldReceive("getUploadtreeTableName")
487  ->withArgs([$args['id']])->andReturn("uploadtree");
488  $this->uploadDao->shouldReceive("getUploadEntry")
489  ->withArgs([$args['itemId'], 'uploadtree'])
490  ->andReturn(['upload_fk' => (string) $args['id']]);
491  $this->dbHelper->shouldReceive("doesIdExist")
492  ->withArgs(['upload','upload_pk', $args['id']])->andReturn(true);
493  $this->restHelper->shouldReceive("getGroupId")
494  ->andReturn(4);
495  $this->uploadDao->shouldReceive("isAccessible")
496  ->withArgs([$args['id'],4])->andReturn(true);
497  $this->copyrightHist->shouldReceive('getAgentId')
498  ->withArgs([$args['id'],'copyright_ars'])->andReturn(1);
499 
500  $this->copyrightHist->shouldReceive('getCopyrights')
501  ->withArgs([$args['id'],2,'uploadtree',1,'author', 'active',true,0,100])->andReturn([$dumRows,10,10]);
502  $requestHeaders = new Headers();
503  $requestHeaders->setHeader('limit', 100);
504  $body = $this->streamFactory->createStream();
505  $request = new Request("GET", new Uri("HTTP", "localhost"),
506  $requestHeaders, [], [], $body);
507  $request = $request->withQueryParams(["status" => "active"]);
508 
509  foreach ($dumRows as $row) {
510  $row['count'] = intval($row['copyright_count']);
511  unset($row['copyright_count']);
512  $finalVal[] = $row;
513  }
514  $totalPages = intval(ceil(10/100));
515  $expectedResponse = (new ResponseHelper())->withHeader('X-Total-Pages',$totalPages)->withJson($finalVal,200);
516  $actualResponse = $this->copyrightController->getFileAuthor($request, new ResponseHelper(),$args);
517  $this->assertEquals($this->getResponseJson($expectedResponse), $this->getResponseJson($actualResponse));
518  $this->assertEquals(200,$actualResponse->getStatusCode());
519  }
520 
521 
528  public function testGetFileEcc()
529  {
530  $dumRows = $this->getDummyData()['dumRows'];
531  $args = $this->getDummyData()['args'];
532  $this->uploadDao->shouldReceive("getUploadtreeTableName")
533  ->withArgs([$args['id']])->andReturn("uploadtree");
534  $this->uploadDao->shouldReceive("getUploadEntry")
535  ->withArgs([$args['itemId'], 'uploadtree'])
536  ->andReturn(['upload_fk' => (string) $args['id']]);
537  $this->dbHelper->shouldReceive("doesIdExist")
538  ->withArgs(['upload','upload_pk', $args['id']])->andReturn(true);
539  $this->restHelper->shouldReceive("getGroupId")
540  ->andReturn(4);
541  $this->uploadDao->shouldReceive("isAccessible")
542  ->withArgs([$args['id'],4])->andReturn(true);
543  $this->copyrightHist->shouldReceive('getAgentId')
544  ->withArgs([$args['id'],'ecc_ars'])->andReturn(1);
545 
546  $this->copyrightHist->shouldReceive('getCopyrights')
547  ->withArgs([$args['id'],2,'uploadtree',1,'ecc', 'active',true,0,100])->andReturn([$dumRows,10,10]);
548  $requestHeaders = new Headers();
549  $requestHeaders->setHeader('limit', 100);
550  $body = $this->streamFactory->createStream();
551  $request = new Request("GET", new Uri("HTTP", "localhost"),
552  $requestHeaders, [], [], $body);
553  $request = $request->withQueryParams(["status" => "active"]);
554 
555  foreach ($dumRows as $row) {
556  $row['count'] = intval($row['copyright_count']);
557  unset($row['copyright_count']);
558  $finalVal[] = $row;
559  }
560  $totalPages = intval(ceil(10/100));
561  $expectedResponse = (new ResponseHelper())->withHeader('X-Total-Pages',$totalPages)->withJson($finalVal,200);
562  $actualResponse = $this->copyrightController->getFileEcc($request, new ResponseHelper(),$args);
563  $this->assertEquals($this->getResponseJson($expectedResponse), $this->getResponseJson($actualResponse));
564  $this->assertEquals(200,$actualResponse->getStatusCode());
565  }
566 
567 
568 
575  public function testGetFileKeyword()
576  {
577  $dumRows = $this->getDummyData()['dumRows'];
578  $args = $this->getDummyData()['args'];
579  $this->uploadDao->shouldReceive("getUploadtreeTableName")
580  ->withArgs([$args['id']])->andReturn("uploadtree");
581  $this->uploadDao->shouldReceive("getUploadEntry")
582  ->withArgs([$args['itemId'], 'uploadtree'])
583  ->andReturn(['upload_fk' => (string) $args['id']]);
584  $this->dbHelper->shouldReceive("doesIdExist")
585  ->withArgs(['upload','upload_pk', $args['id']])->andReturn(true);
586  $this->restHelper->shouldReceive("getGroupId")
587  ->andReturn(4);
588  $this->uploadDao->shouldReceive("isAccessible")
589  ->withArgs([$args['id'],4])->andReturn(true);
590  $this->copyrightHist->shouldReceive('getAgentId')
591  ->withArgs([$args['id'],'keyword_ars'])->andReturn(1);
592 
593  $this->copyrightHist->shouldReceive('getCopyrights')
594  ->withArgs([$args['id'],2,'uploadtree',1,'keyword', 'active',true,0,100])->andReturn([$dumRows,10,10]);
595  $requestHeaders = new Headers();
596  $requestHeaders->setHeader('limit', 100);
597  $body = $this->streamFactory->createStream();
598  $request = new Request("GET", new Uri("HTTP", "localhost"),
599  $requestHeaders, [], [], $body);
600  $request = $request->withQueryParams(["status" => "active"]);
601 
602  foreach ($dumRows as $row) {
603  $row['count'] = intval($row['copyright_count']);
604  unset($row['copyright_count']);
605  $finalVal[] = $row;
606  }
607  $totalPages = intval(ceil(10/100));
608  $expectedResponse = (new ResponseHelper())->withHeader('X-Total-Pages',$totalPages)->withJson($finalVal,200);
609  $actualResponse = $this->copyrightController->getFileKeyword($request, new ResponseHelper(),$args);
610  $this->assertEquals($this->getResponseJson($expectedResponse), $this->getResponseJson($actualResponse));
611  $this->assertEquals(200,$actualResponse->getStatusCode());
612  }
613 
614 
621  public function testGetFileIpra()
622  {
623  $dumRows = $this->getDummyData()['dumRows'];
624  $args = $this->getDummyData()['args'];
625  $this->uploadDao->shouldReceive("getUploadtreeTableName")
626  ->withArgs([$args['id']])->andReturn("uploadtree");
627  $this->uploadDao->shouldReceive("getUploadEntry")
628  ->withArgs([$args['itemId'], 'uploadtree'])
629  ->andReturn(['upload_fk' => (string) $args['id']]);
630  $this->dbHelper->shouldReceive("doesIdExist")
631  ->withArgs(['upload','upload_pk', $args['id']])->andReturn(true);
632  $this->restHelper->shouldReceive("getGroupId")
633  ->andReturn(4);
634  $this->uploadDao->shouldReceive("isAccessible")
635  ->withArgs([$args['id'],4])->andReturn(true);
636  $this->copyrightHist->shouldReceive('getAgentId')
637  ->withArgs([$args['id'],'ipra_ars'])->andReturn(1);
638 
639  $this->copyrightHist->shouldReceive('getCopyrights')
640  ->withArgs([$args['id'],2,'uploadtree',1,'ipra', 'active',true,0,100])->andReturn([$dumRows,10,10]);
641  $requestHeaders = new Headers();
642  $requestHeaders->setHeader('limit', 100);
643  $body = $this->streamFactory->createStream();
644  $request = new Request("GET", new Uri("HTTP", "localhost"),
645  $requestHeaders, [], [], $body);
646  $request = $request->withQueryParams(["status" => "active"]);
647 
648  foreach ($dumRows as $row) {
649  $row['count'] = intval($row['copyright_count']);
650  unset($row['copyright_count']);
651  $finalVal[] = $row;
652  }
653  $totalPages = intval(ceil(10/100));
654  $expectedResponse = (new ResponseHelper())->withHeader('X-Total-Pages',$totalPages)->withJson($finalVal,200);
655  $actualResponse = $this->copyrightController->getFileIpra($request, new ResponseHelper(),$args);
656  $this->assertEquals($this->getResponseJson($expectedResponse), $this->getResponseJson($actualResponse));
657  $this->assertEquals(200,$actualResponse->getStatusCode());
658  }
659 
666  public function testDeleteFileCopyright()
667  {
668  $args = $this->getDummyData()['args'];
669  $args['hash'] = "hash";
670  $userId = 4;
671 
672  $itemTreeBounds = [
673  'itemId' => 2,
674  'uploadId' => 2,
675  'uploadTreeTableName' => "uploadtree",
676  'left' => 1,
677  'right' => 31314
678  ];
679  $this->uploadDao->shouldReceive("getUploadEntry")
680  ->withArgs([$args['itemId'], 'uploadtree'])
681  ->andReturn(['upload_fk' => (string) $args['id']]);
682  $this->dbHelper->shouldReceive("doesIdExist")
683  ->withArgs(['upload','upload_pk', $args['id']])->andReturn(true);
684  $this->restHelper->shouldReceive("getGroupId")
685  ->andReturn(4);
686  $this->uploadDao->shouldReceive("isAccessible")
687  ->withArgs([$args['id'],4])->andReturn(true);
688  $this->uploadDao->shouldReceive("isEditable")
689  ->withArgs([$args['id'],4])->andReturn(true);
690 
691  $this->uploadDao->shouldReceive("getUploadTreeTableName")
692  ->withAnyArgs()->andReturn("uploadtree");
693  $this->restHelper->shouldReceive("getUserId")
694  ->andReturn($userId);
695  $this->copyrightHist->shouldReceive('getTableName')
696  ->withArgs(['statement'])->andReturn("statement");
697  $this->uploadDao->shouldReceive("getItemTreeBounds")
698  ->andReturn($itemTreeBounds);
699  $this->copyrightDao->shouldReceive('updateTable');
700 
701  $requestHeaders = new Headers();
702  $body = $this->streamFactory->createStream();
703  $request = new Request("GET", new Uri("HTTP", "localhost"),
704  $requestHeaders, [], [], $body);
705  $request = $request->withQueryParams(["status" => "active"]);
706 
707  $returnVal = new Info(200, "Successfully removed copyright.", InfoType::INFO);
708  $expectedResponse = (new ResponseHelper())->withJson($returnVal->getArray(),$returnVal->getCode());
709  $actualResponse = $this->copyrightController->deleteFileCopyright($request, new ResponseHelper(),$args);
710 
711  $this->assertEquals($this->getResponseJson($expectedResponse), $this->getResponseJson($actualResponse));
712 
713  }
714 
721  public function testDeleteFileEmail()
722  {
723  $args = $this->getDummyData()['args'];
724  $args['hash'] = "hash";
725  $userId = 4;
726 
727  $itemTreeBounds = [
728  'itemId' => 2,
729  'uploadId' => 2,
730  'uploadTreeTableName' => "uploadtree",
731  'left' => 1,
732  'right' => 31314
733  ];
734  $this->uploadDao->shouldReceive("getUploadEntry")
735  ->withArgs([$args['itemId'], 'uploadtree'])
736  ->andReturn(['upload_fk' => (string) $args['id']]);
737  $this->dbHelper->shouldReceive("doesIdExist")
738  ->withArgs(['upload','upload_pk', $args['id']])->andReturn(true);
739  $this->restHelper->shouldReceive("getGroupId")
740  ->andReturn(4);
741  $this->uploadDao->shouldReceive("isAccessible")
742  ->withArgs([$args['id'],4])->andReturn(true);
743  $this->uploadDao->shouldReceive("isEditable")
744  ->withArgs([$args['id'],4])->andReturn(true);
745 
746  $this->uploadDao->shouldReceive("getUploadTreeTableName")
747  ->withAnyArgs()->andReturn("uploadtree");
748  $this->restHelper->shouldReceive("getUserId")
749  ->andReturn($userId);
750  $this->copyrightHist->shouldReceive('getTableName')
751  ->withArgs(['email'])->andReturn("copyrights");
752  $this->uploadDao->shouldReceive("getItemTreeBounds")
753  ->andReturn($itemTreeBounds);
754  $this->copyrightDao->shouldReceive('updateTable');
755 
756  $requestHeaders = new Headers();
757  $body = $this->streamFactory->createStream();
758  $request = new Request("GET", new Uri("HTTP", "localhost"),
759  $requestHeaders, [], [], $body);
760  $request = $request->withQueryParams(["status" => "active"]);
761 
762  $returnVal = new Info(200, "Successfully removed email.", InfoType::INFO);
763  $expectedResponse = (new ResponseHelper())->withJson($returnVal->getArray(),$returnVal->getCode());
764  $actualResponse = $this->copyrightController->deleteFileEmail($request, new ResponseHelper(),$args);
765 
766  $this->assertEquals($this->getResponseJson($expectedResponse), $this->getResponseJson($actualResponse));
767 
768  }
775  public function testDeleteFileUrl()
776  {
777  $args = $this->getDummyData()['args'];
778  $args['hash'] = "hash";
779  $userId = 4;
780 
781  $itemTreeBounds = [
782  'itemId' => 2,
783  'uploadId' => 2,
784  'uploadTreeTableName' => "uploadtree",
785  'left' => 1,
786  'right' => 31314
787  ];
788  $this->uploadDao->shouldReceive("getUploadEntry")
789  ->withArgs([$args['itemId'], 'uploadtree'])
790  ->andReturn(['upload_fk' => (string) $args['id']]);
791  $this->dbHelper->shouldReceive("doesIdExist")
792  ->withArgs(['upload','upload_pk', $args['id']])->andReturn(true);
793  $this->restHelper->shouldReceive("getGroupId")
794  ->andReturn(4);
795  $this->uploadDao->shouldReceive("isAccessible")
796  ->withArgs([$args['id'],4])->andReturn(true);
797  $this->uploadDao->shouldReceive("isEditable")
798  ->withArgs([$args['id'],4])->andReturn(true);
799 
800  $this->uploadDao->shouldReceive("getUploadTreeTableName")
801  ->withAnyArgs()->andReturn("uploadtree");
802  $this->restHelper->shouldReceive("getUserId")
803  ->andReturn($userId);
804  $this->copyrightHist->shouldReceive('getTableName')
805  ->withArgs(['url'])->andReturn("copyrights");
806  $this->uploadDao->shouldReceive("getItemTreeBounds")
807  ->andReturn($itemTreeBounds);
808  $this->copyrightDao->shouldReceive('updateTable');
809 
810  $requestHeaders = new Headers();
811  $body = $this->streamFactory->createStream();
812  $request = new Request("GET", new Uri("HTTP", "localhost"),
813  $requestHeaders, [], [], $body);
814  $request = $request->withQueryParams(["status" => "active"]);
815 
816  $returnVal = new Info(200, "Successfully removed url.", InfoType::INFO);
817  $expectedResponse = (new ResponseHelper())->withJson($returnVal->getArray(),$returnVal->getCode());
818  $actualResponse = $this->copyrightController->deleteFileUrl($request, new ResponseHelper(),$args);
819 
820  $this->assertEquals($this->getResponseJson($expectedResponse), $this->getResponseJson($actualResponse));
821 
822  }
823 
824 
825 
832  public function testDeleteFileAuthor()
833  {
834  $args = $this->getDummyData()['args'];
835  $args['hash'] = "hash";
836  $userId = 4;
837 
838  $itemTreeBounds = [
839  'itemId' => 2,
840  'uploadId' => 2,
841  'uploadTreeTableName' => "uploadtree",
842  'left' => 1,
843  'right' => 31314
844  ];
845  $this->uploadDao->shouldReceive("getUploadEntry")
846  ->withArgs([$args['itemId'], 'uploadtree'])
847  ->andReturn(['upload_fk' => (string) $args['id']]);
848  $this->dbHelper->shouldReceive("doesIdExist")
849  ->withArgs(['upload','upload_pk', $args['id']])->andReturn(true);
850  $this->restHelper->shouldReceive("getGroupId")
851  ->andReturn(4);
852  $this->uploadDao->shouldReceive("isAccessible")
853  ->withArgs([$args['id'],4])->andReturn(true);
854  $this->uploadDao->shouldReceive("isEditable")
855  ->withArgs([$args['id'],4])->andReturn(true);
856 
857  $this->uploadDao->shouldReceive("getUploadTreeTableName")
858  ->withAnyArgs()->andReturn("uploadtree");
859  $this->restHelper->shouldReceive("getUserId")
860  ->andReturn($userId);
861  $this->copyrightHist->shouldReceive('getTableName')
862  ->withArgs(['author'])->andReturn("copyrights");
863  $this->uploadDao->shouldReceive("getItemTreeBounds")
864  ->andReturn($itemTreeBounds);
865  $this->copyrightDao->shouldReceive('updateTable');
866 
867  $requestHeaders = new Headers();
868  $body = $this->streamFactory->createStream();
869  $request = new Request("GET", new Uri("HTTP", "localhost"),
870  $requestHeaders, [], [], $body);
871  $request = $request->withQueryParams(["status" => "active"]);
872 
873  $returnVal = new Info(200, "Successfully removed author.", InfoType::INFO);
874  $expectedResponse = (new ResponseHelper())->withJson($returnVal->getArray(),$returnVal->getCode());
875  $actualResponse = $this->copyrightController->deleteFileAuthor($request, new ResponseHelper(),$args);
876 
877  $this->assertEquals($this->getResponseJson($expectedResponse), $this->getResponseJson($actualResponse));
878 
879  }
886  public function testDeleteFileEcc()
887  {
888  $args = $this->getDummyData()['args'];
889  $args['hash'] = "hash";
890  $userId = 4;
891 
892  $itemTreeBounds = [
893  'itemId' => 2,
894  'uploadId' => 2,
895  'uploadTreeTableName' => "uploadtree",
896  'left' => 1,
897  'right' => 31314
898  ];
899  $this->uploadDao->shouldReceive("getUploadEntry")
900  ->withArgs([$args['itemId'], 'uploadtree'])
901  ->andReturn(['upload_fk' => (string) $args['id']]);
902  $this->dbHelper->shouldReceive("doesIdExist")
903  ->withArgs(['upload','upload_pk', $args['id']])->andReturn(true);
904  $this->restHelper->shouldReceive("getGroupId")
905  ->andReturn(4);
906  $this->uploadDao->shouldReceive("isAccessible")
907  ->withArgs([$args['id'],4])->andReturn(true);
908  $this->uploadDao->shouldReceive("isEditable")
909  ->withArgs([$args['id'],4])->andReturn(true);
910 
911  $this->uploadDao->shouldReceive("getUploadTreeTableName")
912  ->withAnyArgs()->andReturn("uploadtree");
913  $this->restHelper->shouldReceive("getUserId")
914  ->andReturn($userId);
915  $this->copyrightHist->shouldReceive('getTableName')
916  ->withArgs(['ecc'])->andReturn("copyrights");
917  $this->uploadDao->shouldReceive("getItemTreeBounds")
918  ->andReturn($itemTreeBounds);
919  $this->copyrightDao->shouldReceive('updateTable');
920 
921  $requestHeaders = new Headers();
922  $body = $this->streamFactory->createStream();
923  $request = new Request("GET", new Uri("HTTP", "localhost"),
924  $requestHeaders, [], [], $body);
925  $request = $request->withQueryParams(["status" => "active"]);
926 
927  $returnVal = new Info(200, "Successfully removed ecc.", InfoType::INFO);
928  $expectedResponse = (new ResponseHelper())->withJson($returnVal->getArray(),$returnVal->getCode());
929  $actualResponse = $this->copyrightController->deleteFileEcc($request, new ResponseHelper(),$args);
930 
931  $this->assertEquals($this->getResponseJson($expectedResponse), $this->getResponseJson($actualResponse));
932 
933  }
934 
941  public function testDeleteFileKeyword()
942  {
943  $args = $this->getDummyData()['args'];
944  $args['hash'] = "hash";
945  $userId = 4;
946 
947  $itemTreeBounds = [
948  'itemId' => 2,
949  'uploadId' => 2,
950  'uploadTreeTableName' => "uploadtree",
951  'left' => 1,
952  'right' => 31314
953  ];
954  $this->uploadDao->shouldReceive("getUploadEntry")
955  ->withArgs([$args['itemId'], 'uploadtree'])
956  ->andReturn(['upload_fk' => (string) $args['id']]);
957  $this->dbHelper->shouldReceive("doesIdExist")
958  ->withArgs(['upload','upload_pk', $args['id']])->andReturn(true);
959  $this->restHelper->shouldReceive("getGroupId")
960  ->andReturn(4);
961  $this->uploadDao->shouldReceive("isAccessible")
962  ->withArgs([$args['id'],4])->andReturn(true);
963  $this->uploadDao->shouldReceive("isEditable")
964  ->withArgs([$args['id'],4])->andReturn(true);
965 
966  $this->uploadDao->shouldReceive("getUploadTreeTableName")
967  ->withAnyArgs()->andReturn("uploadtree");
968  $this->restHelper->shouldReceive("getUserId")
969  ->andReturn($userId);
970  $this->copyrightHist->shouldReceive('getTableName')
971  ->withArgs(['keyword'])->andReturn("copyrights");
972  $this->uploadDao->shouldReceive("getItemTreeBounds")
973  ->andReturn($itemTreeBounds);
974  $this->copyrightDao->shouldReceive('updateTable');
975 
976  $requestHeaders = new Headers();
977  $body = $this->streamFactory->createStream();
978  $request = new Request("GET", new Uri("HTTP", "localhost"),
979  $requestHeaders, [], [], $body);
980  $request = $request->withQueryParams(["status" => "active"]);
981 
982  $returnVal = new Info(200, "Successfully removed keyword.", InfoType::INFO);
983  $expectedResponse = (new ResponseHelper())->withJson($returnVal->getArray(),$returnVal->getCode());
984  $actualResponse = $this->copyrightController->deleteFileKeyword($request, new ResponseHelper(),$args);
985 
986  $this->assertEquals($this->getResponseJson($expectedResponse), $this->getResponseJson($actualResponse));
987  }
988 
989 
990 
997  public function testDeleteFileIpra()
998  {
999  $args = $this->getDummyData()['args'];
1000  $args['hash'] = "hash";
1001  $userId = 4;
1002 
1003  $itemTreeBounds = [
1004  'itemId' => 2,
1005  'uploadId' => 2,
1006  'uploadTreeTableName' => "uploadtree",
1007  'left' => 1,
1008  'right' => 31314
1009  ];
1010  $this->uploadDao->shouldReceive("getUploadEntry")
1011  ->withArgs([$args['itemId'], 'uploadtree'])
1012  ->andReturn(['upload_fk' => (string) $args['id']]);
1013  $this->dbHelper->shouldReceive("doesIdExist")
1014  ->withArgs(['upload','upload_pk', $args['id']])->andReturn(true);
1015  $this->restHelper->shouldReceive("getGroupId")
1016  ->andReturn(4);
1017  $this->uploadDao->shouldReceive("isAccessible")
1018  ->withArgs([$args['id'],4])->andReturn(true);
1019  $this->uploadDao->shouldReceive("isEditable")
1020  ->withArgs([$args['id'],4])->andReturn(true);
1021 
1022  $this->uploadDao->shouldReceive("getUploadTreeTableName")
1023  ->withAnyArgs()->andReturn("uploadtree");
1024  $this->restHelper->shouldReceive("getUserId")
1025  ->andReturn($userId);
1026  $this->copyrightHist->shouldReceive('getTableName')
1027  ->withArgs(['ipra'])->andReturn("copyrights");
1028  $this->uploadDao->shouldReceive("getItemTreeBounds")
1029  ->andReturn($itemTreeBounds);
1030  $this->copyrightDao->shouldReceive('updateTable');
1031 
1032  $requestHeaders = new Headers();
1033  $body = $this->streamFactory->createStream();
1034  $request = new Request("GET", new Uri("HTTP", "localhost"),
1035  $requestHeaders, [], [], $body);
1036  $request = $request->withQueryParams(["status" => "active"]);
1037 
1038  $returnVal = new Info(200, "Successfully removed ipra.", InfoType::INFO);
1039  $expectedResponse = (new ResponseHelper())->withJson($returnVal->getArray(),$returnVal->getCode());
1040  $actualResponse = $this->copyrightController->deleteFileIpra($request, new ResponseHelper(),$args);
1041 
1042  $this->assertEquals($this->getResponseJson($expectedResponse), $this->getResponseJson($actualResponse));
1043  }
1044 
1051  public function testDeleteFileCopyrightForbiddenWithReadOnlyPermission()
1052  {
1053  $args = $this->getDummyData()['args'];
1054  $args['hash'] = "hash";
1055 
1056  $this->dbHelper->shouldReceive("doesIdExist")
1057  ->withArgs(['upload', 'upload_pk', $args['id']])->andReturn(true);
1058  $this->restHelper->shouldReceive("getGroupId")
1059  ->andReturn(4);
1060  $this->uploadDao->shouldReceive("isAccessible")
1061  ->withArgs([$args['id'], 4])->andReturn(true);
1062  $this->uploadDao->shouldReceive("isEditable")
1063  ->withArgs([$args['id'], 4])->andReturn(false);
1064 
1065  $this->copyrightDao->shouldNotReceive('updateTable');
1066  $this->copyrightDao->shouldNotReceive('removeDecision');
1067 
1068  $requestHeaders = new Headers();
1069  $body = $this->streamFactory->createStream();
1070  $request = new Request("DELETE", new Uri("HTTP", "localhost"),
1071  $requestHeaders, [], [], $body);
1072 
1073  $this->expectException(
1074  \Fossology\UI\Api\Exceptions\HttpForbiddenException::class);
1075  $this->expectExceptionMessage(
1076  "You do not have write permission on this upload.");
1077  $this->copyrightController->deleteFileCopyright(
1078  $request, new ResponseHelper(), $args);
1079  }
1080 
1087  public function testRestoreFileCopyrightForbiddenWithReadOnlyPermission()
1088  {
1089  $args = $this->getDummyData()['args'];
1090  $args['hash'] = "hash";
1091 
1092  $this->dbHelper->shouldReceive("doesIdExist")
1093  ->withArgs(['upload', 'upload_pk', $args['id']])->andReturn(true);
1094  $this->restHelper->shouldReceive("getGroupId")
1095  ->andReturn(4);
1096  $this->uploadDao->shouldReceive("isAccessible")
1097  ->withArgs([$args['id'], 4])->andReturn(true);
1098  $this->uploadDao->shouldReceive("isEditable")
1099  ->withArgs([$args['id'], 4])->andReturn(false);
1100 
1101  $this->copyrightDao->shouldNotReceive('updateTable');
1102  $this->copyrightDao->shouldNotReceive('undoDecision');
1103 
1104  $requestHeaders = new Headers();
1105  $body = $this->streamFactory->createStream();
1106  $request = new Request("PUT", new Uri("HTTP", "localhost"),
1107  $requestHeaders, [], [], $body);
1108 
1109  $this->expectException(
1110  \Fossology\UI\Api\Exceptions\HttpForbiddenException::class);
1111  $this->expectExceptionMessage(
1112  "You do not have write permission on this upload.");
1113  $this->copyrightController->restoreFileCopyright(
1114  $request, new ResponseHelper(), $args);
1115  }
1116 
1123  public function testUpdateFileCopyrightForbiddenWithReadOnlyPermission()
1124  {
1125  $args = $this->getDummyData()['args'];
1126  $args['hash'] = "hash";
1127 
1128  $this->dbHelper->shouldReceive("doesIdExist")
1129  ->withArgs(['upload', 'upload_pk', $args['id']])->andReturn(true);
1130  $this->restHelper->shouldReceive("getGroupId")
1131  ->andReturn(4);
1132  $this->uploadDao->shouldReceive("isAccessible")
1133  ->withArgs([$args['id'], 4])->andReturn(true);
1134  $this->uploadDao->shouldReceive("isEditable")
1135  ->withArgs([$args['id'], 4])->andReturn(false);
1136 
1137  $this->copyrightDao->shouldNotReceive('updateTable');
1138  $this->copyrightDao->shouldNotReceive('undoDecision');
1139 
1140  $requestHeaders = new Headers();
1141  $body = $this->streamFactory->createStream();
1142  $request = new Request("PATCH", new Uri("HTTP", "localhost"),
1143  $requestHeaders, [], [], $body);
1144 
1145  $this->expectException(
1146  \Fossology\UI\Api\Exceptions\HttpForbiddenException::class);
1147  $this->expectExceptionMessage(
1148  "You do not have write permission on this upload.");
1149  $this->copyrightController->updateFileCopyright(
1150  $request, new ResponseHelper(), $args);
1151  }
1152 }
Fossology\Lib\Auth\Auth
Contains the constants and helpers for authentication of user.
Definition: Auth.php:24
Fossology\UI\Api\Helper\DbHelper
Provides helper methods to access database for REST api.
Definition: DbHelper.php:38
Fossology\UI\Api\Helper\ResponseHelper
Override Slim response for withJson function.
Definition: ResponseHelper.php:22
Fossology\UI\Api\Helper\RestHelper
Provides various DAO helper functions for REST api.
Definition: RestHelper.php:32
Fossology\UI\Api\Models\InfoType
Different type of infos provided by REST.
Definition: InfoType.php:16
Fossology\UI\Api\Models\Info
Info model to contain general error and return values.
Definition: Info.php:19