TestUtil::buildAdapter() - Code Metrics - Inspection of "Set theme jekyll-theme-cayman" - bartko-s/stefano-tree - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( b97768...587712 )

by Bartko

created 2018-07-18 17:41 UTC

TestUtil::buildAdapter() A

↳ Parent: TestUtil

Complexity

Conditions	5
Paths	5

Size

Total Lines

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
dl	0
loc	21
rs	9.2728
c	0
b	0
f	0
cc	5
nc	5
nop	1

<?php

declare(strict_types=1);

namespace StefanoTreeTest;

use Doctrine\DBAL;
use PDO;
use StefanoTree\NestedSet;
use StefanoTree\NestedSet\Options;
use StefanoTree\NestedSet\Adapter;
use StefanoTree\NestedSet\Adapter\AdapterInterface;
use Zend\Db\Adapter\Adapter as Zend2DbAdapter;

class TestUtil
{
    private static $dbConnection;
    private static $zend2DbAdapter;
    private static $zend1DbAdapter;
    private static $doctrine2Connection;

    private static $mysqlDbSchemeCreated = false;

    public static function createDbScheme()
    {
        $connection = self::getPDOConnection();

        $queries = array();

        if ('mysql' == TEST_STEFANO_DB_VENDOR) {
            if (self::$mysqlDbSchemeCreated) {
                return;
            } else {
                self::$mysqlDbSchemeCreated = true;
            }
            $queries[] = 'CREATE TABLE `tree_traversal` (
                `tree_traversal_id` int(11) NOT NULL AUTO_INCREMENT,
                `name` varchar(255) COLLATE utf8_bin DEFAULT NULL,
                `lft` int(11) NOT NULL,
                `rgt` int(11) NOT NULL,
                `parent_id` int(11) DEFAULT NULL,
                `level` int(11) DEFAULT NULL,
                PRIMARY KEY (`tree_traversal_id`),
                KEY `parent_id` (`parent_id`),
                KEY `level` (`level`),
                KEY `lft` (`lft`),
                KEY `rgt` (`rgt`)
            ) ENGINE=InnoDB DEFAULT CHARSET=utf8 COLLATE=utf8_bin';

            $queries[] = 'ALTER TABLE `tree_traversal`
                ADD FOREIGN KEY (`parent_id`) 
                REFERENCES `tree_traversal` (`tree_traversal_id`) 
                ON DELETE CASCADE ON UPDATE CASCADE';

            $queries[] = 'CREATE TABLE `tree_traversal_with_scope` (
                `tree_traversal_id` int(11) NOT NULL AUTO_INCREMENT,
                `name` varchar(255) COLLATE utf8_bin DEFAULT NULL,
                `lft` int(11) NOT NULL,
                `rgt` int(11) NOT NULL,
                `parent_id` int(11) DEFAULT NULL,
                `level` int(11) DEFAULT NULL,
                `scope` int(11) NOT NULL,
                PRIMARY KEY (`tree_traversal_id`),
                KEY `parent_id` (`parent_id`),
                KEY `level` (`level`),
                KEY `lft` (`lft`),
                KEY `rgt` (`rgt`),
                KEY `scope` (`scope`)
            ) ENGINE=InnoDB DEFAULT CHARSET=utf8 COLLATE=utf8_bin';

            $queries[] = 'CREATE TABLE `tree_traversal_metadata` (
                `tree_traversal_metadata_id` int(11) NOT NULL AUTO_INCREMENT,
                `tree_traversal_id` int(11) NOT NULL,
                `lft` int(11) DEFAULT NULL,
                `name` varchar(255) COLLATE utf8_bin DEFAULT NULL,
                PRIMARY KEY (`tree_traversal_metadata_id`),
                KEY `tree_traversal_id` (`tree_traversal_id`)
            ) ENGINE=InnoDB DEFAULT CHARSET=utf8 COLLATE=utf8_bin';

            $queries[] = 'ALTER TABLE `tree_traversal_with_scope`
                ADD FOREIGN KEY (`parent_id`) 
                REFERENCES `tree_traversal_with_scope` (`tree_traversal_id`) 
                ON DELETE CASCADE ON UPDATE CASCADE';
        } elseif ('pgsql' == TEST_STEFANO_DB_VENDOR) {
            // Run this workaround before each test. DbUnit has issue with postgres https://github.com/sebastianbergmann/dbunit/issues/58
            $queries[] = 'DROP TABLE IF EXISTS tree_traversal';
            $queries[] = 'DROP TABLE IF EXISTS tree_traversal_with_scope';
            $queries[] = 'DROP TABLE IF EXISTS tree_traversal_metadata';

            $queries[] = 'CREATE TABLE tree_traversal (
                  tree_traversal_id serial NOT NULL,
                  name character varying(255),
                  lft integer NOT NULL,
                  rgt integer NOT NULL,
                  parent_id integer,
                  level integer,
                  CONSTRAINT tree_traversal_pkey PRIMARY KEY (tree_traversal_id),
                  CONSTRAINT tree_traversal_parent_id_fkey FOREIGN KEY (parent_id)
                    REFERENCES public.tree_traversal (tree_traversal_id) MATCH SIMPLE
                    ON UPDATE CASCADE ON DELETE CASCADE
                )';

            $queries[] = 'CREATE INDEX tree_traversal_level
                ON public.tree_traversal
                USING btree (level)';

            $queries[] = 'CREATE INDEX tree_traversal_lft
                ON public.tree_traversal
                USING btree (lft)';

            $queries[] = 'CREATE INDEX tree_traversal_parent_id
                ON public.tree_traversal
                USING btree (parent_id)';

            $queries[] = 'CREATE INDEX tree_traversal_rgt
                  ON public.tree_traversal
                  USING btree (rgt)';

            $queries[] = 'CREATE TABLE tree_traversal_with_scope (
                  tree_traversal_id serial NOT NULL,
                  name character varying(255),
                  lft integer NOT NULL,
                  rgt integer NOT NULL,
                  parent_id integer,
                  level integer,
                  scope integer NOT NULL,
                  CONSTRAINT tree_traversal_with_scope_pkey PRIMARY KEY (tree_traversal_id),
                  CONSTRAINT tree_traversal_with_scope_parent_id_fkey FOREIGN KEY (parent_id)
                    REFERENCES public.tree_traversal_with_scope (tree_traversal_id) MATCH SIMPLE
                    ON UPDATE CASCADE ON DELETE CASCADE
                )';

            $queries[] = 'CREATE INDEX tree_traversal_with_scope_level
                  ON public.tree_traversal_with_scope
                  USING btree (level)';

            $queries[] = 'CREATE INDEX tree_traversal_with_scope_lft
                  ON public.tree_traversal_with_scope
                  USING btree (lft)';

            $queries[] = 'CREATE INDEX tree_traversal_with_scope_parent_id
                  ON public.tree_traversal_with_scope
                  USING btree (parent_id)';

            $queries[] = 'CREATE INDEX tree_traversal_with_scope_rgt
                  ON public.tree_traversal_with_scope
                  USING btree (rgt)';

            $queries[] = 'CREATE INDEX tree_traversal_with_scope_scope
                  ON public.tree_traversal_with_scope
                  USING btree (scope)';

            $queries[] = 'CREATE TABLE tree_traversal_metadata (
                tree_traversal_metadata_id serial NOT NULL,
                tree_traversal_id integer NOT NULL,
                lft integer,
                name character varying(255),
                CONSTRAINT tree_traversal_metadata_pkey PRIMARY KEY (tree_traversal_metadata_id)
            )';

            $queries[] = 'CREATE INDEX tree_traversal_metadata_tree_traversal_id
                  ON public.tree_traversal_metadata
                  USING btree (tree_traversal_id)';
        } else {
            throw new \Exception(sprintf('Unsupported vendor %s', TEST_STEFANO_DB_VENDOR));
        }

        foreach ($queries as $query) {
            $connection->query($query);
        }
    }

    /**
     * Singleton.
     *
     * @return PDO
     */
    public static function getPDOConnection()
    {
        if (null == self::$dbConnection) {
            $adapter = strtolower(TEST_STEFANO_DB_VENDOR);
            $hostname = TEST_STEFANO_DB_HOSTNAME;
            $dbName = TEST_STEFANO_DB_DB_NAME;
            $user = TEST_STEFANO_DB_USER;
            $password = TEST_STEFANO_DB_PASSWORD;

            self::$dbConnection = new PDO(
                $adapter.':host='.$hostname.';dbname='
                .$dbName, $user, $password
            );
        }

        return self::$dbConnection;
    }

    /**
     * Singleton.
     *
     * @return Zend2DbAdapter
     */
    public static function getZend2DbAdapter()
    {
        if (null == self::$zend2DbAdapter) {
            self::$zend2DbAdapter = new Zend2DbAdapter(array(
                'driver' => 'Pdo_'.ucfirst(TEST_STEFANO_DB_VENDOR),
                'hostname' => TEST_STEFANO_DB_HOSTNAME,
                'database' => TEST_STEFANO_DB_DB_NAME,
                'username' => TEST_STEFANO_DB_USER,
                'password' => TEST_STEFANO_DB_PASSWORD,
            ));
        }

        return self::$zend2DbAdapter;
    }

    /**
     * Singleton.
     *
     * @return \Zend_Db_Adapter_Abstract
     */
    public static function getZend1DbAdapter()
    {
        if (null == self::$zend1DbAdapter) {
            self::$zend1DbAdapter = \Zend_Db::factory('Pdo_'.ucfirst(TEST_STEFANO_DB_VENDOR), array(
                'host' => TEST_STEFANO_DB_HOSTNAME,
                'dbname' => TEST_STEFANO_DB_DB_NAME,
                'username' => TEST_STEFANO_DB_USER,
                'password' => TEST_STEFANO_DB_PASSWORD,
            ));
        }

        return self::$zend1DbAdapter;
    }

    /**
     * Singleton.
     *
     * @return DBAL\Connection
     */
    public static function getDoctrine2Connection()
    {
        if (null == self::$doctrine2Connection) {
            $config = new DBAL\Configuration();
            $connectionParams = array(
                'dbname' => TEST_STEFANO_DB_DB_NAME,
                'user' => TEST_STEFANO_DB_USER,
                'password' => TEST_STEFANO_DB_PASSWORD,
                'host' => TEST_STEFANO_DB_HOSTNAME,
                'driver' => 'pdo_'.strtolower(TEST_STEFANO_DB_VENDOR),
            );

            self::$doctrine2Connection = DBAL\DriverManager::getConnection($connectionParams, $config);
        }

        return self::$doctrine2Connection;
    }

    /**
     * Build Adapter based on ENV variable TEST_STEFANO_ADAPTER.
     *
     * @param Options $options
     *
     * @return AdapterInterface
     */
    public static function buildAdapter(Options $options): NestedSet\Adapter\AdapterInterface
    {
        switch (TEST_STEFANO_ADAPTER) {
            case 'pdo':
                $adapter = new Adapter\Pdo($options, self::getPDOConnection());
                break;
            case 'zend1':
                $adapter = new Adapter\Zend1($options, self::getZend1DbAdapter());
                break;
            case 'zend2':
                $adapter = new Adapter\Zend2($options, self::getZend2DbAdapter());
                break;
            case 'doctrine2-dbal':
                $adapter = new Adapter\Doctrine2DBAL($options, self::getDoctrine2Connection());
                break;
            default:
                throw new \Exception(sprintf('Unknown adapter "%s"', TEST_STEFANO_ADAPTER));
        }

        return $adapter;
    }
}


1			<?php
2
3			declare(strict_types=1);
4
5			namespace StefanoTreeTest;
6
7			use Doctrine\DBAL;
8			use PDO;
9			use StefanoTree\NestedSet;
10			use StefanoTree\NestedSet\Options;
11			use StefanoTree\NestedSet\Adapter;
12			use StefanoTree\NestedSet\Adapter\AdapterInterface;
13			use Zend\Db\Adapter\Adapter as Zend2DbAdapter;
14
15			class TestUtil
16			{
17			private static $dbConnection;
18			private static $zend2DbAdapter;
19			private static $zend1DbAdapter;
20			private static $doctrine2Connection;
21
22			private static $mysqlDbSchemeCreated = false;
23
24			public static function createDbScheme()
25			{
26			$connection = self::getPDOConnection();
27
28			$queries = array();
29
30			if ('mysql' == TEST_STEFANO_DB_VENDOR) {
31			if (self::$mysqlDbSchemeCreated) {
32			return;
33			} else {
34			self::$mysqlDbSchemeCreated = true;
35			}
36			$queries[] = 'CREATE TABLE `tree_traversal` (
37			`tree_traversal_id` int(11) NOT NULL AUTO_INCREMENT,
38			`name` varchar(255) COLLATE utf8_bin DEFAULT NULL,
39			`lft` int(11) NOT NULL,
40			`rgt` int(11) NOT NULL,
41			`parent_id` int(11) DEFAULT NULL,
42			`level` int(11) DEFAULT NULL,
43			PRIMARY KEY (`tree_traversal_id`),
44			KEY `parent_id` (`parent_id`),
45			KEY `level` (`level`),
46			KEY `lft` (`lft`),
47			KEY `rgt` (`rgt`)
48			) ENGINE=InnoDB DEFAULT CHARSET=utf8 COLLATE=utf8_bin';
49
50			$queries[] = 'ALTER TABLE `tree_traversal`
51			ADD FOREIGN KEY (`parent_id`)
52			REFERENCES `tree_traversal` (`tree_traversal_id`)
53			ON DELETE CASCADE ON UPDATE CASCADE';
54
55			$queries[] = 'CREATE TABLE `tree_traversal_with_scope` (
56			`tree_traversal_id` int(11) NOT NULL AUTO_INCREMENT,
57			`name` varchar(255) COLLATE utf8_bin DEFAULT NULL,
58			`lft` int(11) NOT NULL,
59			`rgt` int(11) NOT NULL,
60			`parent_id` int(11) DEFAULT NULL,
61			`level` int(11) DEFAULT NULL,
62			`scope` int(11) NOT NULL,
63			PRIMARY KEY (`tree_traversal_id`),
64			KEY `parent_id` (`parent_id`),
65			KEY `level` (`level`),
66			KEY `lft` (`lft`),
67			KEY `rgt` (`rgt`),
68			KEY `scope` (`scope`)
69			) ENGINE=InnoDB DEFAULT CHARSET=utf8 COLLATE=utf8_bin';
70
71			$queries[] = 'CREATE TABLE `tree_traversal_metadata` (
72			`tree_traversal_metadata_id` int(11) NOT NULL AUTO_INCREMENT,
73			`tree_traversal_id` int(11) NOT NULL,
74			`lft` int(11) DEFAULT NULL,
75			`name` varchar(255) COLLATE utf8_bin DEFAULT NULL,
76			PRIMARY KEY (`tree_traversal_metadata_id`),
77			KEY `tree_traversal_id` (`tree_traversal_id`)
78			) ENGINE=InnoDB DEFAULT CHARSET=utf8 COLLATE=utf8_bin';
79
80			$queries[] = 'ALTER TABLE `tree_traversal_with_scope`
81			ADD FOREIGN KEY (`parent_id`)
82			REFERENCES `tree_traversal_with_scope` (`tree_traversal_id`)
83			ON DELETE CASCADE ON UPDATE CASCADE';
84			} elseif ('pgsql' == TEST_STEFANO_DB_VENDOR) {
85			// Run this workaround before each test. DbUnit has issue with postgres https://github.com/sebastianbergmann/dbunit/issues/58
86			$queries[] = 'DROP TABLE IF EXISTS tree_traversal';
87			$queries[] = 'DROP TABLE IF EXISTS tree_traversal_with_scope';
88			$queries[] = 'DROP TABLE IF EXISTS tree_traversal_metadata';
89
90			$queries[] = 'CREATE TABLE tree_traversal (
91			tree_traversal_id serial NOT NULL,
92			name character varying(255),
93			lft integer NOT NULL,
94			rgt integer NOT NULL,
95			parent_id integer,
96			level integer,
97			CONSTRAINT tree_traversal_pkey PRIMARY KEY (tree_traversal_id),
98			CONSTRAINT tree_traversal_parent_id_fkey FOREIGN KEY (parent_id)
99			REFERENCES public.tree_traversal (tree_traversal_id) MATCH SIMPLE
100			ON UPDATE CASCADE ON DELETE CASCADE
101			)';
102
103			$queries[] = 'CREATE INDEX tree_traversal_level
104			ON public.tree_traversal
105			USING btree (level)';
106
107			$queries[] = 'CREATE INDEX tree_traversal_lft
108			ON public.tree_traversal
109			USING btree (lft)';
110
111			$queries[] = 'CREATE INDEX tree_traversal_parent_id
112			ON public.tree_traversal
113			USING btree (parent_id)';
114
115			$queries[] = 'CREATE INDEX tree_traversal_rgt
116			ON public.tree_traversal
117			USING btree (rgt)';
118
119			$queries[] = 'CREATE TABLE tree_traversal_with_scope (
120			tree_traversal_id serial NOT NULL,
121			name character varying(255),
122			lft integer NOT NULL,
123			rgt integer NOT NULL,
124			parent_id integer,
125			level integer,
126			scope integer NOT NULL,
127			CONSTRAINT tree_traversal_with_scope_pkey PRIMARY KEY (tree_traversal_id),
128			CONSTRAINT tree_traversal_with_scope_parent_id_fkey FOREIGN KEY (parent_id)
129			REFERENCES public.tree_traversal_with_scope (tree_traversal_id) MATCH SIMPLE
130			ON UPDATE CASCADE ON DELETE CASCADE
131			)';
132
133			$queries[] = 'CREATE INDEX tree_traversal_with_scope_level
134			ON public.tree_traversal_with_scope
135			USING btree (level)';
136
137			$queries[] = 'CREATE INDEX tree_traversal_with_scope_lft
138			ON public.tree_traversal_with_scope
139			USING btree (lft)';
140
141			$queries[] = 'CREATE INDEX tree_traversal_with_scope_parent_id
142			ON public.tree_traversal_with_scope
143			USING btree (parent_id)';
144
145			$queries[] = 'CREATE INDEX tree_traversal_with_scope_rgt
146			ON public.tree_traversal_with_scope
147			USING btree (rgt)';
148
149			$queries[] = 'CREATE INDEX tree_traversal_with_scope_scope
150			ON public.tree_traversal_with_scope
151			USING btree (scope)';
152
153			$queries[] = 'CREATE TABLE tree_traversal_metadata (
154			tree_traversal_metadata_id serial NOT NULL,
155			tree_traversal_id integer NOT NULL,
156			lft integer,
157			name character varying(255),
158			CONSTRAINT tree_traversal_metadata_pkey PRIMARY KEY (tree_traversal_metadata_id)
159			)';
160
161			$queries[] = 'CREATE INDEX tree_traversal_metadata_tree_traversal_id
162			ON public.tree_traversal_metadata
163			USING btree (tree_traversal_id)';
164			} else {
165			throw new \Exception(sprintf('Unsupported vendor %s', TEST_STEFANO_DB_VENDOR));
166			}
167
168			foreach ($queries as $query) {
169			$connection->query($query);
170			}
171			}
172
173			/**
174			* Singleton.
175			*
176			* @return PDO
177			*/
178			public static function getPDOConnection()
179			{
180			if (null == self::$dbConnection) {
181			$adapter = strtolower(TEST_STEFANO_DB_VENDOR);
182			$hostname = TEST_STEFANO_DB_HOSTNAME;
183			$dbName = TEST_STEFANO_DB_DB_NAME;
184			$user = TEST_STEFANO_DB_USER;
185			$password = TEST_STEFANO_DB_PASSWORD;
186
187			self::$dbConnection = new PDO(
188			$adapter.':host='.$hostname.';dbname='
189			.$dbName, $user, $password
190			);
191			}
192
193			return self::$dbConnection;
194			}
195
196			/**
197			* Singleton.
198			*
199			* @return Zend2DbAdapter
200			*/
201			public static function getZend2DbAdapter()
202			{
203			if (null == self::$zend2DbAdapter) {
204			self::$zend2DbAdapter = new Zend2DbAdapter(array(
205			'driver' => 'Pdo_'.ucfirst(TEST_STEFANO_DB_VENDOR),
206			'hostname' => TEST_STEFANO_DB_HOSTNAME,
207			'database' => TEST_STEFANO_DB_DB_NAME,
208			'username' => TEST_STEFANO_DB_USER,
209			'password' => TEST_STEFANO_DB_PASSWORD,
210			));
211			}
212
213			return self::$zend2DbAdapter;
214			}
215
216			/**
217			* Singleton.
218			*
219			* @return \Zend_Db_Adapter_Abstract
220			*/
221			public static function getZend1DbAdapter()
222			{
223			if (null == self::$zend1DbAdapter) {
224			self::$zend1DbAdapter = \Zend_Db::factory('Pdo_'.ucfirst(TEST_STEFANO_DB_VENDOR), array(
225			'host' => TEST_STEFANO_DB_HOSTNAME,
226			'dbname' => TEST_STEFANO_DB_DB_NAME,
227			'username' => TEST_STEFANO_DB_USER,
228			'password' => TEST_STEFANO_DB_PASSWORD,
229			));
230			}
231
232			return self::$zend1DbAdapter;
233			}
234
235			/**
236			* Singleton.
237			*
238			* @return DBAL\Connection
239			*/
240			public static function getDoctrine2Connection()
241			{
242			if (null == self::$doctrine2Connection) {
243			$config = new DBAL\Configuration();
244			$connectionParams = array(
245			'dbname' => TEST_STEFANO_DB_DB_NAME,
246			'user' => TEST_STEFANO_DB_USER,
247			'password' => TEST_STEFANO_DB_PASSWORD,
248			'host' => TEST_STEFANO_DB_HOSTNAME,
249			'driver' => 'pdo_'.strtolower(TEST_STEFANO_DB_VENDOR),
250			);
251
252			self::$doctrine2Connection = DBAL\DriverManager::getConnection($connectionParams, $config);
253			}
254
255			return self::$doctrine2Connection;
256			}
257
258			/**
259			* Build Adapter based on ENV variable TEST_STEFANO_ADAPTER.
260			*
261			* @param Options $options
262			*
263			* @return AdapterInterface
264			*/
265			public static function buildAdapter(Options $options): NestedSet\Adapter\AdapterInterface
266			{
267			switch (TEST_STEFANO_ADAPTER) {
268			case 'pdo':
269			$adapter = new Adapter\Pdo($options, self::getPDOConnection());
270			break;
271			case 'zend1':
272			$adapter = new Adapter\Zend1($options, self::getZend1DbAdapter());
273			break;
274			case 'zend2':
275			$adapter = new Adapter\Zend2($options, self::getZend2DbAdapter());
276			break;
277			case 'doctrine2-dbal':
278			$adapter = new Adapter\Doctrine2DBAL($options, self::getDoctrine2Connection());
279			break;
280			default:
281			throw new \Exception(sprintf('Unknown adapter "%s"', TEST_STEFANO_ADAPTER));
282			}
283
284			return $adapter;
285			}
286			}
287

bartko-s / stefano-tree

Push — master ( b97768...587712 )

TestUtil::buildAdapter() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like