/**
  * @param array $data
  *
  * @return void
  * @dataProvider getData
  */
 public function test_function(array $data)
 {
     // prepare
     $this->setExpectedException($data['exception'], $data['errorMessage']);
     // invoke logic & test
     SimpleArrayLibrary::setColumn($data['matrix'], $data['column'], 1, $data['insertIfMissing'], $data['overwrite']);
 }
 /**
  * @return void
  */
 public function test_function()
 {
     // prepare
     $this->setExpectedException('UnexpectedValueException', 'Array of config keys must be numeric');
     // invoke logic & test
     SimpleArrayLibrary::addConfigRow([], ['z' => 1], 1);
 }
 /**
  * @param array $data
  *
  * @return void
  * @dataProvider getData
  */
 public function test_function(array $data)
 {
     // prepare
     $this->setExpectedException($data['exception'], $data['errorMessage']);
     // invoke logic & test
     SimpleArrayLibrary::deleteColumns($data['matrix'], $data['columns']);
 }
 /**
  * @return void
  */
 public function test_function()
 {
     // prepare
     $this->setExpectedException('InvalidArgumentException', 'Strict comparison parameter must be a boolean');
     // invoke logic & test
     SimpleArrayLibrary::isSubArray(array(), array(), array());
 }
 /**
  * TearDown remove dummy data from one or more collections
  *
  * @param array $records
  *
  * @throws \UnexpectedValueException
  * @return void
  */
 public function tearDown(array $records = [])
 {
     if (empty($records)) {
         if (is_array($this->data)) {
             foreach ($this->data as $collection => $rows) {
                 $records[$collection] = array_keys($rows);
             }
         }
     } elseif (SimpleArrayLibrary::countMaxDepth($records) == 1) {
         $this->validateCollections($records);
         $temp = [];
         foreach ($records as $collection) {
             $temp[$collection] = array_keys($this->data[$collection]);
         }
         $records = $temp;
     } else {
         foreach ($records as $collection => $ids) {
             $this->validateIds($collection, $ids);
         }
     }
     foreach ($records as $collection => $ids) {
         foreach ($ids as $id) {
             $this->delete($collection, $id);
         }
     }
 }
 /**
  * @param array $data
  *
  * @return void
  * @dataProvider getData
  */
 public function test_function(array $data)
 {
     // prepare
     $this->setExpectedException($data['exception'], $data['errorMessage']);
     // invoke logic & test
     SimpleArrayLibrary::getColumns($data['array'], $data['columns'], $data['allRowsMustHaveAllColumns']);
 }
 /**
  * @param array $data
  *
  * @return void
  * @dataProvider getData
  */
 public function test_function(array $data)
 {
     // invoke logic
     $result = SimpleArrayLibrary::hasAllKeys($data['array'], $data['keys']);
     // test
     $this->assertEquals($data['expected'], $result);
 }
 /**
  * @param array $data
  *
  * @return void
  * @dataProvider getData
  */
 public function test_function(array $data)
 {
     // invoke logic
     $result = SimpleArrayLibrary::haveEqualValues($data['array1'], $data['array2']);
     // test
     $this->assertEquals($data['expected'], $result);
 }
 /**
  * @param array $data
  *
  * @return void
  * @dataProvider getData
  */
 public function test_function(array $data)
 {
     // prepare
     $this->setExpectedException($data['exception'], $data['errorMessage']);
     // invoke logic & test
     SimpleArrayLibrary::castColumns($data['matrix'], $data['map'], $data['allKeysMustBePresent']);
 }
 /**
  * @param array $data
  *
  * @return void
  * @dataProvider getData
  */
 public function test_function(array $data)
 {
     // prepare
     $this->setExpectedException($data['exception'], $data['errorMessage']);
     // invoke logic & test
     SimpleArrayLibrary::insertSubArray($data['array'], $data['subArray'], $data['overwrite'], $data['ignoreIfExists']);
 }
 /**
  * @return void
  */
 public function test_function()
 {
     // prepare
     $this->setExpectedException('InvalidArgumentException', 'Depth parameter must be an integer');
     // invoke logic & test
     SimpleArrayLibrary::countMinDepth('a', 'z');
 }
 /**
  * @param array $data
  *
  * @return void
  * @dataProvider getData
  */
 public function test_function(array $data)
 {
     // invoke logic & test
     if (!$data['allKeysMustBePresent']) {
         $this->assertEquals($data['expResult'], SimpleArrayLibrary::castColumns($data['matrix'], $data['columns'], $data['allKeysMustBePresent']));
     } else {
         $this->assertEquals($data['expResult'], SimpleArrayLibrary::castColumns($data['matrix'], $data['columns']));
     }
 }
 /**
  * @param array $data
  *
  * @return void
  * @dataProvider getData
  */
 public function test_function(array $data)
 {
     // invoke logic & test
     if (!empty($data['allRowsMustHaveAllColumns'])) {
         $this->assertEquals($data['expResult'], SimpleArrayLibrary::getColumns($data['matrix'], $data['columns'], $data['allRowsMustHaveAllColumns']));
     } else {
         $this->assertEquals($data['expResult'], SimpleArrayLibrary::getColumns($data['matrix'], $data['columns']));
     }
 }
 /**
  * @param array $data
  *
  * @return void
  * @dataProvider getData
  */
 public function test_function(array $data)
 {
     // invoke logic & test
     if (isset($data['value'])) {
         $this->assertEquals($data['expResult'], SimpleArrayLibrary::allElementsEqual($data['array'], $data['value']));
     } else {
         $this->assertEquals($data['expResult'], SimpleArrayLibrary::allElementsEqual($data['array']));
     }
 }
Example #15
0
 /**
  * @param array  $initialData
  * @param string $database
  * @param array  $dependencies
  *
  * @throws AlreadyInitializedException
  */
 public static function initMongo(array $initialData, $database, array $dependencies)
 {
     if (!static::$instance) {
         if (empty($database) || !is_string($database)) {
             throw new UnexpectedValueException('Invalid database name');
         }
         if (!SimpleArrayLibrary::isAssociative($initialData) && !empty($initialData)) {
             throw new UnexpectedValueException('Invalid collection names');
         }
         static::$initialData = $initialData;
         static::initDependencyHandler($initialData, $dependencies);
         $client = new \MongoClient();
         static::$instance->database = $client->selectDB($database);
         // edit $data array where needed
         static::$instance->update();
     } else {
         throw new AlreadyInitializedException('Mongo library already initialized');
     }
 }
Example #16
0
 /**
  * @param array  $initialData
  * @param string $serverName
  * @param string $database
  * @param string $username
  * @param string $password
  * @param array  $dependencies
  *
  * @throws AlreadyInitializedException
  */
 public static function initMySQL(array $initialData, $serverName, $database, $username, $password, array $dependencies)
 {
     if (!static::$instance) {
         if (empty($serverName) || !is_string($serverName)) {
             throw new UnexpectedValueException('Invalid server name');
         }
         if (empty($database) || !is_string($database)) {
             throw new UnexpectedValueException('Invalid database name');
         }
         if (empty($username) || !is_string($username)) {
             throw new UnexpectedValueException('Invalid username');
         }
         if (!is_string($password)) {
             throw new UnexpectedValueException('Invalid password');
         }
         if (!SimpleArrayLibrary::isAssociative($initialData) && !empty($initialData)) {
             throw new UnexpectedValueException('Invalid table names');
         }
         static::$initialData = $initialData;
         static::initDependencyHandler($initialData, $dependencies);
         static::$instance->connection = new PDO('mysql:host=' . $serverName . ';dbname=' . $database, $username, $password);
         static::$instance->primaryKeys = [];
         foreach ($initialData as $table => $data) {
             $stmt = static::$instance->connection->prepare("SHOW KEYS FROM {$table} WHERE Key_name = 'PRIMARY'");
             $stmt->execute();
             static::$instance->primaryKeys[$table] = [];
             foreach ($stmt->fetchAll() as $row) {
                 static::$instance->primaryKeys[$table][] = $row['Column_name'];
             }
         }
         foreach (static::$instance->primaryKeys as $table => $keys) {
             foreach ($initialData[$table] as $row) {
                 if (!SimpleArrayLibrary::hasAllKeys($row, $keys)) {
                     throw new UnexpectedValueException('Missing keys in initial data for table: ' . $table);
                 }
             }
         }
         // edit $data array where needed
         static::$instance->update();
     } else {
         throw new AlreadyInitializedException('MySQL library already initialized');
     }
 }
 /**
  * @param array $data
  *
  * @return void
  * @dataProvider getData
  */
 public function test_function(array $data)
 {
     // invoke logic & test
     $this->assertEquals($data['expResult'], SimpleArrayLibrary::setColumn($data['matrix'], $data['column'], 1, $data['insertIfMissing'], $data['overwrite']));
 }
 /**
  * @return void
  */
 public function test_function()
 {
     // invoke logic & test
     $this->assertEquals(array('foo' => array('baz' => 1, 'bar' => 2)), SimpleArrayLibrary::addConfigRow(array('foo' => array('baz' => 1)), array('foo', 'bar'), 2));
 }
 /**
  * @param array $data
  *
  * @return void
  * @dataProvider getData
  */
 public function test_function(array $data)
 {
     // invoke logic & test
     $this->assertEquals($data['expResult'], SimpleArrayLibrary::isAssociative($data['array']));
 }
 /**
  * @param array $data
  *
  * @return void
  * @dataProvider getData
  */
 public function test_function(array $data)
 {
     // invoke logic & test
     $this->assertEquals($data['expResult'], SimpleArrayLibrary::insertSubArray($data['array'], $data['subArray'], $data['overwrite'], $data['ignoreIfExists']));
 }
 /**
  * Edits $data array
  *
  * @param array|string $value
  * @param string       $collection
  * @param string       $id
  * @param string       $field
  *
  * @return void
  */
 public function saveData($value, $collection = '', $id = '', $field = '')
 {
     if (!empty($collection)) {
         if (!empty($id)) {
             if (!empty($field)) {
                 if (!isset($this->data[$collection])) {
                     throw new UnexpectedValueException('Non existing collection');
                 }
                 if (!isset($this->data[$collection][$id])) {
                     throw new UnexpectedValueException('Non existing row');
                 }
                 $this->data[$collection][$id][$field] = $value;
             } else {
                 if (!is_array($value)) {
                     throw new UnexpectedValueException('Row should be an array of fields');
                 }
                 $data[$collection] = isset($data[$collection]) ? $data[$collection] : [];
                 $this->data[$collection][$id] = $value;
             }
         } else {
             if (SimpleArrayLibrary::countMaxDepth($value) <= 1) {
                 throw new UnexpectedValueException('Collection has to be array of rows which are all arrays of fields');
             }
             $this->data[$collection] = $value;
         }
     } else {
         if (SimpleArrayLibrary::countMaxDepth($value) <= 2) {
             throw new UnexpectedValueException('Data has to be an array of collections which are all arrays of rows which are all arrays of fields');
         }
         $this->data = $value;
     }
 }
 /**
  * @param array $repacked
  *
  * @return array
  */
 protected function compactDependencies(array $repacked)
 {
     if (SimpleArrayLibrary::countMaxDepth($repacked) != 2 || SimpleArrayLibrary::countMinDepth($repacked) != 2) {
         throw new UnexpectedValueException('Invalid input');
     }
     $return = [];
     foreach ($repacked as $collection => $data) {
         $i = $data['i'];
         unset($data['i']);
         $return[$i] = [$collection => array_unique($data)];
     }
     ksort($return);
     $return = array_values($return);
     $return = array_reverse($return);
     return $return;
 }
 /**
  * @param array $data
  *
  * @return void
  * @dataProvider getData
  */
 public function test_function(array $data)
 {
     // invoke logic & test
     $this->assertEquals($data['expResult'], SimpleArrayLibrary::countMaxDepth($data['array'], $data['depth']));
 }
 /**
  * @param array $data
  *
  * @return void
  * @dataProvider getData
  */
 public function test_function(array $data)
 {
     // invoke logic & test
     $this->assertEquals($data['expResult'], SimpleArrayLibrary::deleteColumns($data['matrix'], $data['columns']));
 }
 /**
  * @param array $data
  *
  * @return void
  * @dataProvider getData
  */
 public function test_function(array $data)
 {
     // invoke logic & test
     $this->assertEquals($data['expResult'], SimpleArrayLibrary::getRectangularDimensions($data['array']));
 }
Example #26
0
 /**
  * @param array        $table
  * @param string       $column
  * @param string       $condition
  * @param array|string $value
  *
  * @return array
  * @throws InvalidArgumentException
  */
 public static function whereCondition(array $table, $column, $condition, $value)
 {
     // input validation
     if (!is_numeric($column) && (empty($column) || !is_string($column))) {
         throw new InvalidArgumentException('Invalid column parameter');
     }
     if (count(SimpleArrayLibrary::getRectangularDimensions($table)) != 2) {
         if (empty($table)) {
             return [];
         } else {
             throw new InvalidArgumentException('Table is not a rectangular 2 dimensional array');
         }
     }
     $validConditions = ['>', '<', '=', '==', '>=', '<=', '<>', 'in', 'notin'];
     $condition = strtolower($condition);
     if (!in_array($condition, $validConditions)) {
         throw new InvalidArgumentException('Invalid condition parameter');
     }
     if (in_array($condition, ['in', 'notin']) && !is_array($value)) {
         throw new InvalidArgumentException('In case of "in" & "notin" conditions, value must be an array');
     } elseif (!in_array($condition, ['in', 'notin']) && !is_numeric($value) && !is_string($value) && !is_null($value)) {
         throw new InvalidArgumentException('Invalid value');
     }
     $return = [];
     $tableNumeric = !SimpleArrayLibrary::isAssociative($table);
     foreach ($table as $index => $row) {
         if (!isset($row[$column])) {
             throw new InvalidArgumentException('Column missing from row: ' . $index);
         }
         $keep = true;
         switch ($condition) {
             case '>':
                 $keep = $row[$column] > $value;
                 break;
             case '<':
                 $keep = $row[$column] < $value;
                 break;
             case '>=':
                 $keep = $row[$column] >= $value;
                 break;
             case '<=':
                 $keep = $row[$column] <= $value;
                 break;
             case '=':
             case '==':
                 $keep = $row[$column] == $value;
                 break;
             case '<>':
                 $keep = $row[$column] != $value;
                 break;
             case 'in':
                 $keep = in_array($row[$column], $value);
                 break;
             case 'notin':
                 $keep = !in_array($row[$column], $value);
                 break;
         }
         if ($keep) {
             if ($tableNumeric) {
                 $return[] = $row;
             } else {
                 $return[$index] = $row;
             }
         }
     }
     return $return;
 }