Merge pull request #91 from ivandiazwm/master

PHP 7.1, linear congruential generator

.travis.yml

@@ -3,6 +3,7 @@ language: php
 php:
   - '5.6'
   - '7.0'
+  - '7.1'
 
 services:
   - mysql
@@ -27,5 +28,7 @@ before_install:
 script:
 - cd client
 - npm test
+- cd ../server
+- ./run-tests.sh
 - cd ../tests
 - bacon init.rb

server/composer.json

@@ -9,6 +9,6 @@
         "ezyang/htmlpurifier": "^4.8"
     },
     "require-dev": {
-      "phpunit/phpunit": "5.0.*"
+        "phpunit/phpunit": "^5.7"
     }
 }

server/controllers/user/login.php

@@ -58,8 +58,7 @@ class LoginController extends Controller {
 
         if ($this->checkInputCredentials() || $this->checkRememberToken()) {
             if($this->userInstance->verificationToken !== null) {
-                Response::respondError(ERRORS::UNVERIFIED_USER);
-                return;
+                throw new Exception(ERRORS::UNVERIFIED_USER);
             }
 
             $this->createUserSession();
@@ -71,7 +70,7 @@ class LoginController extends Controller {
 
             Response::respondSuccess($this->getUserData());
         } else {
-            Response::respondError(ERRORS::INVALID_CREDENTIALS);
+            throw new Exception(ERRORS::INVALID_CREDENTIALS);
         }
     }
 

server/libs/Hashing.php

@@ -30,8 +30,10 @@ class Hashing {
         $sqrt = sqrt($number);
         $prime = true;
 
-        for($i = 0; $i < $sqrt; $i++) {
-            if($sqrt % 2 === 0) {
+        if($number <= 1) return false;
+
+        for($i = 2; $i <= $sqrt; $i++) {
+            if($number % $i === 0) {
                 $prime = false;
                 break;
             }

server/libs/LinearCongruentialGenerator.php

@@ -21,8 +21,10 @@ class LinearCongruentialGenerator {
     }
 
     public function generate($offset) {
-        if($offset) return ($this->first - $this->min + $offset * $this->gap) % ($this->max - $this->min + 1) + $this->min;
-        else return $this->generateFirst();
+        if(!$this->first) throw new Exception('LinearCongruentialGenerator: first is not set');
+        if(!$this->gap) throw new Exception('LinearCongruentialGenerator: gap is not set');
+
+        return ($this->first - $this->min + $offset * $this->gap) % ($this->max - $this->min + 1) + $this->min;
     }
 
     public function generateFirst() {

server/models/DataStore.php

@@ -134,7 +134,6 @@ abstract class DataStore {
 
     public function delete() {
         RedBean::trash($this->getBeanInstance());
-        unset($this);
     }
 
     public function getBeanInstance() {

server/run-tests.sh

@@ -1,3 +1,3 @@
-phpunit --colors tests/models
-phpunit --colors tests/controllers
-phpunit --colors tests/libs
+./vendor/bin/phpunit --colors tests/models
+./vendor/bin/phpunit --colors tests/controllers
+./vendor/bin/phpunit --colors tests/libs

server/tests/__lib__/Mock.php

@@ -44,8 +44,9 @@ class Stub {
 }
 
 class Mock {
+
     public static function stub() {
-        return new Stub;
+        return new Stub();
     }
 
     public static function setStatics($statics) {
@@ -55,7 +56,7 @@ class Mock {
     }
 
     public static function __callStatic($key, $arguments) {
-        if (static::$functionList[$key]) {
+        if (array_key_exists($key, static::$functionList)) {
             $function =  static::$functionList[$key];
 
             return call_user_func_array($function, $arguments);
@@ -87,9 +88,11 @@ class Mock {
     }
 
     public function __call($method, $arguments) {
-        if (isset($this->{$method}) && is_callable($this->{$method})) {
+        if ($this->{$method} && is_callable($this->$method)) {
             return call_user_func_array($this->{$method}, $arguments);
-        } else if (!self::__callStatic($method, $arguments)) {
+        } else if (array_key_exists($method, static::$functionList)) {
+            return self::__callStatic($method, $arguments);
+        } else {
             throw new Exception("Fatal error: Call to undefined method stdObject::{$method}()");
         }
     }

server/tests/__mocks__/ControllerMock.php

@@ -1,12 +1,20 @@
 <?php
 
-class Controller extends \Mock {
-    public static $functionList = array();
+class Controller {
+    public static $requestReturnMock = 'mockRequestValue';
+    public static $checkUserLoggedReturnMock = true;
+    public static $isUserSystemEnabledReturnMock = true;
 
-    public static function initStubs() {
-        parent::setStatics(array(
-            'request' => parent::stub()->returns('mockRequestValue'),
-            'checkUserLogged' => parent::stub()->returns(true)
-        ));
+    public static function request($value) {
+        if($value === 'staff') return false;
+        return static::$requestReturnMock;
+    }
+
+    public static function checkUserLogged() {
+        return static::$checkUserLoggedReturnMock;
+    }
+
+    public static function isUserSystemEnabled() {
+        return static::$isUserSystemEnabledReturnMock;
     }
 }

server/tests/__mocks__/HashingMock.php

@@ -1,6 +1,6 @@
 <?php
 
-class Session extends \Mock {
+class Hashing extends \Mock {
     public static $functionList = array();
 
     public static function initStubs() {
@@ -10,20 +10,4 @@ class Session extends \Mock {
             'generateRandomToken' => parent::stub()->returns('TEST_TOKEN')
         ));
     }
-
-    public static function mockInstanceFunction($functionName, $functionMock) {
-        self::getInstance()->{$functionName} = $functionMock;
-    }
-
-    private static function getInstanceMock() {
-        return new \Mock(array(
-            'initSession' => parent::stub(),
-            'closeSession' => parent::stub(),
-            'createSession' => parent::stub(),
-            'getToken' => parent::stub()->returns('TEST_TOKEN'),
-            'sessionExists' => parent::stub()->returns(false),
-            'checkAuthentication' => parent::stub()->returns(true),
-            'isLoggedWithId' => parent::stub()->returns(true),
-        ));
-    }
 }

server/tests/__mocks__/SessionCookieMock.php

@@ -0,0 +1,26 @@
+<?php
+class SessionCookie extends \Mock {
+    public static $functionList = array();
+    public $user;
+
+    public static function getDataStore() {
+        return new SessionCookie();
+    }
+
+    public function __construct() {
+        $this->user = new \Mock();
+        $this->user->id = 'MOCK_ID';
+    }
+
+    public function isNull() {
+        return false;
+    }
+
+    public function setProperties() {
+        return null;
+    }
+
+    public function store() {
+        return null;
+    }
+}

server/tests/__mocks__/SlimMock.php

@@ -9,7 +9,10 @@ namespace Slim {
             if (self::$instance === null) {
                 self::$instance = new \Mock();
                 self::$instance->setBody = \Mock::stub();
+                self::$instance->setStatus = \Mock::stub();
                 self::$instance->finalize = \Mock::stub();
+                self::$instance->headers = new \Mock();
+                self::$instance->headers->set = \Mock::stub();
             }
 
             return self::$instance;
@@ -18,6 +21,7 @@ namespace Slim {
 
     class Slim extends \Mock {
         protected static $instance;
+        public static $functionList = [];
 
         public function __construct() {
         }
@@ -25,7 +29,7 @@ namespace Slim {
         public static function getInstance() {
             if (self::$instance === null) {
                 self::$instance = new Slim();
-                self::$instance->response = \Mock::stub()->returns(Response::getInstance());
+                self::$instance->response = Response::getInstance();
             }
 
             return self::$instance;

server/tests/controllers/user/loginTest.php

@@ -6,18 +6,22 @@ include_once 'tests/__mocks__/ResponseMock.php';
 include_once 'tests/__mocks__/ControllerMock.php';
 include_once 'tests/__mocks__/SessionMock.php';
 include_once 'tests/__mocks__/UserMock.php';
+include_once 'tests/__mocks__/HashingMock.php';
+include_once 'tests/__mocks__/SessionCookieMock.php';
 include_once 'data/ERRORS.php';
 
 include_once 'controllers/user/login.php';
 
-class LoginControllerTest extends PHPUnit_Framework_TestCase {
+use PHPUnit\Framework\TestCase;
+
+class LoginControllerTest extends TestCase {
     private $loginController;
 
     protected function setUp() {
         Session::initStubs();
-        Controller::initStubs();
         User::initStubs();
         Response::initStubs();
+        $_SERVER['REMOTE_ADDR'] = 'MOCK_REMOTE';
 
         $this->loginController = new LoginController();
     }
@@ -25,9 +29,9 @@ class LoginControllerTest extends PHPUnit_Framework_TestCase {
     public function testShouldRespondErrorIfAlreadyLoggedIn() {
         Session::mockInstanceFunction('sessionExists', \Mock::stub()->returns(true));
 
-        $this->loginController->handler();
+        $this->expectExceptionMessage(ERRORS::SESSION_EXISTS);
 
-        $this->assertTrue(Response::get('respondError')->hasBeenCalledWithArgs(ERRORS::SESSION_EXISTS));
+        $this->loginController->handler();
     }
 
     public function testShouldCreateSessionAndRespondSuccessIfCredentialsAreValid() {
@@ -35,11 +39,11 @@ class LoginControllerTest extends PHPUnit_Framework_TestCase {
 
         $this->loginController->handler();
 
-        $this->assertTrue(Session::getInstance()->createSession->hasBeenCalledWithArgs('MOCK_ID', null));
+        $this->assertTrue(!!Session::getInstance()->createSession->hasBeenCalledWithArgs('MOCK_ID', false));
         $this->assertTrue(Response::get('respondSuccess')->hasBeenCalledWithArgs(array(
             'userId' => 'MOCK_ID',
             'userEmail' => 'MOCK_EMAIL',
-            'staff' => null,
+            'staff' => false,
             'token' => 'TEST_TOKEN',
             'rememberToken' => null
         )));
@@ -50,8 +54,10 @@ class LoginControllerTest extends PHPUnit_Framework_TestCase {
             'authenticate' => \Mock::stub()->returns(new NullDataStore())
         ));
 
-        $this->loginController->handler();
+        Controller::$requestReturnMock = '';
 
-        $this->assertTrue(Response::get('respondError')->hasBeenCalledWithArgs(ERRORS::INVALID_CREDENTIALS));
+        $this->expectExceptionMessage(ERRORS::INVALID_CREDENTIALS);
+
+        $this->loginController->handler();
     }
 }

server/tests/libs/HashingTest.php

@@ -0,0 +1,73 @@
+<?php
+include_once 'libs/Hashing.php';
+
+use PHPUnit\Framework\TestCase;
+
+class HashingTest extends TestCase {
+
+    public function testShouldGenerateRandomToken() {
+        $token1 = Hashing::generateRandomToken();
+        $token2 = Hashing::generateRandomToken();
+
+        $this->assertNotEquals($token1, $token2);
+    }
+
+    public function testShouldHashAndVerifyPassword() {
+        $TEST_TIMES = 5;
+
+        for ($i = 0; $i < $TEST_TIMES; $i++) {
+            $password = Hashing::generateRandomToken();
+            $passwordHash = Hashing::hashPassword($password);
+
+            $this->assertTrue(Hashing::verifyPassword($password, $passwordHash));
+            $this->assertFalse(Hashing::verifyPassword('', $passwordHash));
+            $this->assertFalse(Hashing::verifyPassword($password, ''));
+            $this->assertFalse(Hashing::verifyPassword('', ''));
+            $this->assertFalse(Hashing::verifyPassword($password . 'a', $passwordHash));
+            $this->assertFalse(Hashing::verifyPassword($password, $passwordHash . 'a'));
+        }
+
+    }
+
+    public function testShouldGenerateNumber() {
+        $TEST_TIMES = 10;
+
+        for ($i = 0; $i < $TEST_TIMES; $i++) {
+            $min = $i*1000;
+            $max = $TEST_TIMES*6000;
+
+            $number1 = Hashing::generateRandomNumber($min, $max);
+            $number2 = Hashing::generateRandomNumber($min, $max);
+
+            $this->assertTrue($min < $number1 && $number1 < $max);
+            $this->assertTrue($min < $number2 && $number2 < $max);
+            $this->assertNotEquals($number1, $number2);
+        }
+    }
+
+    public function testShouldRecognizePrime() {
+        $primes = [2, 3, 5, 7, 11, 17, 53, 163, 379, 401, 443, 449, 701];
+        $nonPrimes = [0, 1, 4, 27, 40, 51, 155, 363, 381, 511, 703, 928];
+
+        foreach($primes as $number) $this->assertTrue(Hashing::isPrime($number));
+        foreach($nonPrimes as $number) $this->assertFalse(Hashing::isPrime($number));
+    }
+
+    public function testShouldGenerateRandsomPrime() {
+        $TEST_TIMES = 10;
+
+        for ($i = 0; $i < $TEST_TIMES; $i++) {
+            $min = $i*1000;
+            $max = $TEST_TIMES*6000;
+
+            $number1 = Hashing::generateRandomPrime($min, $max);
+            $number2 = Hashing::generateRandomPrime($min, $max);
+
+            $this->assertTrue($min < $number1 && $number1 < $max);
+            $this->assertTrue($min < $number2 && $number2 < $max);
+            $this->assertNotEquals($number1, $number2);
+            $this->assertTrue(Hashing::isPrime($number1));
+            $this->assertTrue(Hashing::isPrime($number2));
+        }
+    }
+}

server/tests/libs/LinearCongruentialGeneratorTest.php

@@ -0,0 +1,30 @@
+<?php
+include_once 'libs/Hashing.php';
+include_once 'libs/LinearCongruentialGenerator.php';
+
+use PHPUnit\Framework\TestCase;
+
+class LinearCongruentialGeneratorTest extends TestCase {
+
+    public function testAvoidCollisions() {
+        $TEST_TIMES = 10;
+        $GENERATE_TIMES = 500000;
+        $min = 100000;
+        $max = 999999;
+
+        for($i = 0; $i < $TEST_TIMES; $i++) {
+            $linearCongruentialGenerator = new LinearCongruentialGenerator();
+            $linearCongruentialGenerator->setRange($min, $max);
+            $linearCongruentialGenerator->setGap(Hashing::generateRandomPrime($min, $max));
+            $linearCongruentialGenerator->setFirst($linearCongruentialGenerator->generateFirst());
+
+            $used = [];
+
+            for($j = 0; $j < $GENERATE_TIMES; $j++) {
+                $generatedNumber = $linearCongruentialGenerator->generate($j);
+                $this->assertFalse(array_key_exists($generatedNumber, $used));
+                $used[$generatedNumber] = true;
+            }
+        }
+    }
+}

server/tests/libs/validations/captchaTest.php

@@ -8,11 +8,12 @@ include_once 'tests/__mocks__/ReCaptchaMock.php';
 
 include_once 'libs/validations/captcha.php';
 
-class CaptchaValidationTest extends PHPUnit_Framework_TestCase {
+use PHPUnit\Framework\TestCase;
+
+class CaptchaValidationTest extends TestCase {
 
     protected function setUp() {
         Setting::initStubs();
-        Controller::initStubs();
         APIKey::initStubs();
         \ReCaptcha\ReCaptcha::initVerify();
 

server/tests/models/DataStoreTest.php

@@ -6,6 +6,7 @@ include_once 'tests/__mocks__/RedBeanMock.php';
 include_once 'models/DataStore.php';
 
 use RedBeanPHP\Facade as RedBean;
+use PHPUnit\Framework\TestCase;
 
 class DataStoreMock extends DataStore {
     const TABLE = 'MOCK_TABLE';
@@ -26,7 +27,7 @@ class DataStoreMock extends DataStore {
     }
 }
 
-class DataStoreTest extends PHPUnit_Framework_TestCase {
+class DataStoreTest extends TestCase {
 
     protected function setUp() {
         RedBean::initStubs();

server/tests/models/MailTemplateTest.php

@@ -6,8 +6,9 @@ include_once 'tests/__mocks__/RedBeanMock.php';
 include_once 'models/MailTemplate.php';
 
 use RedBeanPHP\Facade as RedBean;
+use PHPUnit\Framework\TestCase;
 
-class MailTemplateTest extends PHPUnit_Framework_TestCase {
+class MailTemplateTest extends TestCase {
 
     protected function setUp() {
         RedBean::initStubs();

server/tests/models/ResponseTest.php

@@ -3,7 +3,9 @@ include_once 'tests/__lib__/Mock.php';
 include_once 'tests/__mocks__/SlimMock.php';
 include_once 'models/Response.php';
 
-class ResponseTest extends PHPUnit_Framework_TestCase {
+use PHPUnit\Framework\TestCase;
+
+class ResponseTest extends TestCase {
     public function testErrorResponseFormat() {
         //Mock data
         $mockErrorValue = 'MOCK_ERROR_VALUE';
@@ -13,7 +15,8 @@ class ResponseTest extends PHPUnit_Framework_TestCase {
             'message' => $mockErrorValue,
             'data' => $mockData
         ));
-        $responseInstance = \Slim\Slim::getInstance()->response();
+        $responseInstance = \Slim\Slim::getInstance();
+        $responseInstance = $responseInstance->response;
 
         //Execute Response
         Response::respondError($mockErrorValue, $mockData);
@@ -31,7 +34,7 @@ class ResponseTest extends PHPUnit_Framework_TestCase {
             'message' => $mockErrorValue,
             'data' => null
         ));
-        $responseInstance = \Slim\Slim::getInstance()->response();
+        $responseInstance = \Slim\Slim::getInstance()->response;
 
         //Execute Response
         Response::respondError($mockErrorValue);
@@ -48,7 +51,7 @@ class ResponseTest extends PHPUnit_Framework_TestCase {
             'status' => 'success',
             'data' => $mockData
         ));
-        $responseInstance = \Slim\Slim::getInstance()->response();
+        $responseInstance = \Slim\Slim::getInstance()->response;
 
         //Execute Response
         Response::respondSuccess($mockData);
@@ -64,7 +67,7 @@ class ResponseTest extends PHPUnit_Framework_TestCase {
             'status' => 'success',
             'data' => null
         ));
-        $responseInstance = \Slim\Slim::getInstance()->response();
+        $responseInstance = \Slim\Slim::getInstance()->response;
 
         //Execute Response
         Response::respondSuccess();