StockTest::testNegativeQuantity() - Code Metrics - Inspection of "Ampliado el test de stock para comprobar que no ha..." - NeoRazorX/facturascripts - Measure and Improve Code Quality continuously with Scrutinizer

Test Failed

Push — master ( 29ee7d...cd8ddc )

by Carlos

created 2021-11-30 19:50 UTC

StockTest::testNegativeQuantity() A

↳ Parent: StockTest

Complexity

Conditions	1
Paths	1

Size

Total Lines	19
Code Lines	10

Duplication

Lines	0
Ratio	0 %

Importance

Changes	1
Bugs	0	Features	0

Metric	Value
eloc	10
c	1
b	0
f	0
dl	0
loc	19
rs	9.9332
cc	1
nc	1
nop	0

<?php
/**
 * This file is part of FacturaScripts
 * Copyright (C) 2017-2021  Carlos Garcia Gomez <[email protected]>
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU Lesser General Public License as
 * published by the Free Software Foundation, either version 3 of the
 * License, or (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 * GNU Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public License
 * along with this program. If not, see <http://www.gnu.org/licenses/>.
 */

namespace FacturaScripts\Test\Core\Model;

use FacturaScripts\Core\Model\Almacen;
use FacturaScripts\Core\Model\Producto;
use FacturaScripts\Core\Model\Stock;
use FacturaScripts\Core\Model\Variante;
use FacturaScripts\Test\Core\LogErrorsTrait;
use PHPUnit\Framework\TestCase;

final class StockTest extends TestCase
{
    use LogErrorsTrait;

    public function testCreate()
    {
        // creamos un producto
        $product = $this->getRandomProduct();
        $this->assertTrue($product->save(), 'product-can-not-save');

        // añadimos stock al producto
        $stock = new Stock();
        $stock->idproducto = $product->idproducto;
        $stock->referencia = $product->referencia;
        $this->assertTrue($stock->save(), 'stock-can-not-save');
        $this->assertNotNull($stock->primaryColumnValue(), 'stock-not-stored');
        $this->assertTrue($stock->exists(), 'stock-can-not-persist');

        // borrar el producto borra el stock
        $this->assertTrue($product->delete(), 'product-cant-delete');
        $this->assertFalse($stock->exists(), 'stock-not-removed-when-delete-product');
    }

    public function testCantCreateWithoutProduct()
    {
        $stock = new Stock();
        $stock->cantidad = 10;
        $this->assertFalse($stock->save(), 'stock-can-not-create-without-product');
    }

    public function testStockChangesProduct()
    {
        // creamos un producto
        $product = $this->getRandomProduct();
        $this->assertTrue($product->save(), 'product-cant-save');
        $this->assertEquals(0, $product->stockfis, 'new-product-cant-have-stock');

        // añadimos stock
        $stock = new Stock();
        $stock->idproducto = $product->idproducto;
        $stock->referencia = $product->referencia;
        $stock->cantidad = 10;
        $this->assertTrue($stock->save(), 'stock-can-not-save');
        $this->assertEquals(10, $stock->cantidad, 'stock-quantity-changed');

        // refrescamos producto
        $product->loadFromCode($product->idproducto);
        $this->assertEquals(10, $product->stockfis, 'product-stock-not-update');

        // cambiamos el stock
        $stock->cantidad = 7;
        $this->assertTrue($stock->save(), 'stock-can-not-update');
        $this->assertEquals(7, $stock->cantidad, 'stock-quantity-not-changed');

        // refrescamos producto
        $product->loadFromCode($product->idproducto);
        $this->assertEquals(7, $product->stockfis, 'product-stock-not-update');

        // borramos el stock
        $this->assertTrue($stock->delete(), 'stock-cant-delete');

        // refrescamos producto
        $product->loadFromCode($product->idproducto);
        $this->assertEquals(0, $product->stockfis, 'stock-not-update');

        // borramos el producto
        $this->assertTrue($product->delete(), 'product-cant-delete');
    }

    public function testMultiWarehouse()
    {
        // creamos un producto
        $product = $this->getRandomProduct();
        $this->assertTrue($product->save(), 'product-cant-save');

        // creamos 2 almacenes
        $warehouse1 = $this->getRandomWarehouse();
        $this->assertTrue($warehouse1->save(), 'warehouse-cant-save');
        $warehouse2 = $this->getRandomWarehouse();
        $this->assertTrue($warehouse2->save(), 'warehouse-cant-save');

        // añadimos stock al primer almacén
        $stock1 = new Stock();
        $stock1->codalmacen = $warehouse1->codalmacen;
        $stock1->idproducto = $product->idproducto;
        $stock1->referencia = $product->referencia;
        $stock1->cantidad = 10;
        $this->assertTrue($stock1->save(), 'stock-cant-save');

        // añadimos stock al segundo almacén
        $stock2 = new Stock();
        $stock2->codalmacen = $warehouse2->codalmacen;
        $stock2->idproducto = $product->idproducto;
        $stock2->referencia = $product->referencia;
        $stock2->cantidad = 5;
        $this->assertTrue($stock2->save(), 'stock-cant-save');

        // comprobamos que el stock del producto es el stock de todos los almacenes
        $product->loadFromCode($product->idproducto);
        $this->assertEquals(15, $product->stockfis, 'producto-stock-not-the-sum');

        // borramos
        $this->assertTrue($product->delete(), 'product-cant-delete');
        $this->assertTrue($warehouse1->delete(), 'warehouse-cant-delete');
        $this->assertTrue($warehouse2->delete(), 'warehouse-cant-delete');
    }

    public function testMultiWarehouseMultiVariant()
    {
        // creamos un producto
        $product = $this->getRandomProduct();
        $this->assertTrue($product->save(), 'product-cant-save');

        // creamos otra variante
        $variant = new Variante();
        $variant->idproducto = $product->idproducto;
        $variant->referencia = '97897987987';
        $this->assertTrue($variant->save(), 'can-not-create-new-variant');

        // creamos 2 almacenes
        $warehouse1 = $this->getRandomWarehouse();
        $this->assertTrue($warehouse1->save(), 'warehouse-cant-save');
        $warehouse2 = $this->getRandomWarehouse();
        $this->assertTrue($warehouse2->save(), 'warehouse-cant-save');

        // añadimos stock al primer almacén
        foreach ($product->getVariants() as $var) {
            $stock1 = new Stock();
            $stock1->codalmacen = $warehouse1->codalmacen;
            $stock1->idproducto = $var->idproducto;
            $stock1->referencia = $var->referencia;
            $stock1->cantidad = 9;
            $this->assertTrue($stock1->save(), 'stock-cant-save');
        }

        // añadimos stock al segundo almacén
        foreach ($product->getVariants() as $var) {
            $stock2 = new Stock();
            $stock2->codalmacen = $warehouse2->codalmacen;
            $stock2->idproducto = $var->idproducto;
            $stock2->referencia = $var->referencia;
            $stock2->cantidad = 3;
            $this->assertTrue($stock2->save(), 'stock-cant-save');
        }

        // comprobamos que el stock del producto es el stock de todas las variantes en los almacenes
        $product->loadFromCode($product->idproducto);
        $this->assertEquals(24, $product->stockfis, 'producto-stock-not-the-sum');

        // borramos
        $this->assertTrue($product->delete(), 'product-cant-delete');
        $this->assertTrue($warehouse1->delete(), 'warehouse-cant-delete');
        $this->assertTrue($warehouse2->delete(), 'warehouse-cant-delete');
    }

    public function testAvailableStock()
    {
        // creamos el producto
        $product = $this->getRandomProduct();
        $this->assertTrue($product->save(), 'product-cant-save');

        // añadimos stock
        $stock = new Stock();
        $stock->idproducto = $product->idproducto;
        $stock->referencia = $product->referencia;
        $stock->cantidad = 10;
        $stock->reservada = 5;
        $this->assertTrue($stock->save(), 'stock-cant-save');

        // comprobamos
        $this->assertTrue($stock->disponible < $stock->cantidad, 'stock-available-wrong');
        $this->assertEquals(5, $stock->disponible);

        // eliminamos
        $this->assertTrue($stock->delete(), 'stock-cant-delete');
        $this->assertTrue($product->delete(), 'product-cant-delete');
    }

    public function testNegativeQuantity()
    {
        // creamos el producto
        $product = $this->getRandomProduct();
        $this->assertTrue($product->save(), 'product-cant-save');

        // añadimos stock
        $stock = new Stock();
        $stock->idproducto = $product->idproducto;
        $stock->referencia = $product->referencia;
        $stock->cantidad = -10;
        $this->assertTrue($stock->save(), 'stock-cant-save');

        // comprobamos
        $this->assertEquals(0, $stock->cantidad);

        // eliminamos
        $this->assertTrue($stock->delete(), 'stock-cant-delete');
        $this->assertTrue($product->delete(), 'product-cant-delete');
    }

    public function testNegativeAvailable()
    {
        // creamos el producto
        $product = $this->getRandomProduct();
        $this->assertTrue($product->save(), 'product-cant-save');

        // añadimos stock
        $stock = new Stock();
        $stock->idproducto = $product->idproducto;
        $stock->referencia = $product->referencia;
        $stock->cantidad = 2;
        $stock->reservada = 10;
        $this->assertTrue($stock->save(), 'stock-cant-save');

        // comprobamos
        $this->assertEquals(0, $stock->cantidad);

        // eliminamos
        $this->assertTrue($stock->delete(), 'stock-cant-delete');
        $this->assertTrue($product->delete(), 'product-cant-delete');
    }

    private function getRandomProduct(): Producto
    {
        $num = mt_rand(1, 9999);
        $product = new Producto();
        $product->referencia = 'test' . $num;
        $product->descripcion = 'Test Product ' . $num;
        return $product;
    }

    private function getRandomWarehouse(): Almacen
    {
        $warehouse = new Almacen();
        $warehouse->nombre = 'Warehouse ' . mt_rand(1, 99);
        return $warehouse;
    }

    protected function tearDown()
    {
        $this->logErrors();
    }
}


1			<?php
2			/**
3			* This file is part of FacturaScripts
4			* Copyright (C) 2017-2021 Carlos Garcia Gomez <[email protected]>
5			*
6			* This program is free software: you can redistribute it and/or modify
7			* it under the terms of the GNU Lesser General Public License as
8			* published by the Free Software Foundation, either version 3 of the
9			* License, or (at your option) any later version.
10			*
11			* This program is distributed in the hope that it will be useful,
12			* but WITHOUT ANY WARRANTY; without even the implied warranty of
13			* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14			* GNU Lesser General Public License for more details.
15			*
16			* You should have received a copy of the GNU Lesser General Public License
17			* along with this program. If not, see <http://www.gnu.org/licenses/>.
18			*/
19
20			namespace FacturaScripts\Test\Core\Model;
21
22			use FacturaScripts\Core\Model\Almacen;
23			use FacturaScripts\Core\Model\Producto;
24			use FacturaScripts\Core\Model\Stock;
25			use FacturaScripts\Core\Model\Variante;
26			use FacturaScripts\Test\Core\LogErrorsTrait;
27			use PHPUnit\Framework\TestCase;
28
29			final class StockTest extends TestCase
30			{
31			use LogErrorsTrait;
32
33			public function testCreate()
34			{
35			// creamos un producto
36			$product = $this->getRandomProduct();
37			$this->assertTrue($product->save(), 'product-can-not-save');
38
39			// añadimos stock al producto
40			$stock = new Stock();
41			$stock->idproducto = $product->idproducto;
42			$stock->referencia = $product->referencia;
43			$this->assertTrue($stock->save(), 'stock-can-not-save');
44			$this->assertNotNull($stock->primaryColumnValue(), 'stock-not-stored');
45			$this->assertTrue($stock->exists(), 'stock-can-not-persist');
46
47			// borrar el producto borra el stock
48			$this->assertTrue($product->delete(), 'product-cant-delete');
49			$this->assertFalse($stock->exists(), 'stock-not-removed-when-delete-product');
50			}
51
52			public function testCantCreateWithoutProduct()
53			{
54			$stock = new Stock();
55			$stock->cantidad = 10;
56			$this->assertFalse($stock->save(), 'stock-can-not-create-without-product');
57			}
58
59			public function testStockChangesProduct()
60			{
61			// creamos un producto
62			$product = $this->getRandomProduct();
63			$this->assertTrue($product->save(), 'product-cant-save');
64			$this->assertEquals(0, $product->stockfis, 'new-product-cant-have-stock');
65
66			// añadimos stock
67			$stock = new Stock();
68			$stock->idproducto = $product->idproducto;
69			$stock->referencia = $product->referencia;
70			$stock->cantidad = 10;
71			$this->assertTrue($stock->save(), 'stock-can-not-save');
72			$this->assertEquals(10, $stock->cantidad, 'stock-quantity-changed');
73
74			// refrescamos producto
75			$product->loadFromCode($product->idproducto);
76			$this->assertEquals(10, $product->stockfis, 'product-stock-not-update');
77
78			// cambiamos el stock
79			$stock->cantidad = 7;
80			$this->assertTrue($stock->save(), 'stock-can-not-update');
81			$this->assertEquals(7, $stock->cantidad, 'stock-quantity-not-changed');
82
83			// refrescamos producto
84			$product->loadFromCode($product->idproducto);
85			$this->assertEquals(7, $product->stockfis, 'product-stock-not-update');
86
87			// borramos el stock
88			$this->assertTrue($stock->delete(), 'stock-cant-delete');
89
90			// refrescamos producto
91			$product->loadFromCode($product->idproducto);
92			$this->assertEquals(0, $product->stockfis, 'stock-not-update');
93
94			// borramos el producto
95			$this->assertTrue($product->delete(), 'product-cant-delete');
96			}
97
98			public function testMultiWarehouse()
99			{
100			// creamos un producto
101			$product = $this->getRandomProduct();
102			$this->assertTrue($product->save(), 'product-cant-save');
103
104			// creamos 2 almacenes
105			$warehouse1 = $this->getRandomWarehouse();
106			$this->assertTrue($warehouse1->save(), 'warehouse-cant-save');
107			$warehouse2 = $this->getRandomWarehouse();
108			$this->assertTrue($warehouse2->save(), 'warehouse-cant-save');
109
110			// añadimos stock al primer almacén
111			$stock1 = new Stock();
112			$stock1->codalmacen = $warehouse1->codalmacen;
113			$stock1->idproducto = $product->idproducto;
114			$stock1->referencia = $product->referencia;
115			$stock1->cantidad = 10;
116			$this->assertTrue($stock1->save(), 'stock-cant-save');
117
118			// añadimos stock al segundo almacén
119			$stock2 = new Stock();
120			$stock2->codalmacen = $warehouse2->codalmacen;
121			$stock2->idproducto = $product->idproducto;
122			$stock2->referencia = $product->referencia;
123			$stock2->cantidad = 5;
124			$this->assertTrue($stock2->save(), 'stock-cant-save');
125
126			// comprobamos que el stock del producto es el stock de todos los almacenes
127			$product->loadFromCode($product->idproducto);
128			$this->assertEquals(15, $product->stockfis, 'producto-stock-not-the-sum');
129
130			// borramos
131			$this->assertTrue($product->delete(), 'product-cant-delete');
132			$this->assertTrue($warehouse1->delete(), 'warehouse-cant-delete');
133			$this->assertTrue($warehouse2->delete(), 'warehouse-cant-delete');
134			}
135
136			public function testMultiWarehouseMultiVariant()
137			{
138			// creamos un producto
139			$product = $this->getRandomProduct();
140			$this->assertTrue($product->save(), 'product-cant-save');
141
142			// creamos otra variante
143			$variant = new Variante();
144			$variant->idproducto = $product->idproducto;
145			$variant->referencia = '97897987987';
146			$this->assertTrue($variant->save(), 'can-not-create-new-variant');
147
148			// creamos 2 almacenes
149			$warehouse1 = $this->getRandomWarehouse();
150			$this->assertTrue($warehouse1->save(), 'warehouse-cant-save');
151			$warehouse2 = $this->getRandomWarehouse();
152			$this->assertTrue($warehouse2->save(), 'warehouse-cant-save');
153
154			// añadimos stock al primer almacén
155			foreach ($product->getVariants() as $var) {
156			$stock1 = new Stock();
157			$stock1->codalmacen = $warehouse1->codalmacen;
158			$stock1->idproducto = $var->idproducto;
159			$stock1->referencia = $var->referencia;
160			$stock1->cantidad = 9;
161			$this->assertTrue($stock1->save(), 'stock-cant-save');
162			}
163
164			// añadimos stock al segundo almacén
165			foreach ($product->getVariants() as $var) {
166			$stock2 = new Stock();
167			$stock2->codalmacen = $warehouse2->codalmacen;
168			$stock2->idproducto = $var->idproducto;
169			$stock2->referencia = $var->referencia;
170			$stock2->cantidad = 3;
171			$this->assertTrue($stock2->save(), 'stock-cant-save');
172			}
173
174			// comprobamos que el stock del producto es el stock de todas las variantes en los almacenes
175			$product->loadFromCode($product->idproducto);
176			$this->assertEquals(24, $product->stockfis, 'producto-stock-not-the-sum');
177
178			// borramos
179			$this->assertTrue($product->delete(), 'product-cant-delete');
180			$this->assertTrue($warehouse1->delete(), 'warehouse-cant-delete');
181			$this->assertTrue($warehouse2->delete(), 'warehouse-cant-delete');
182			}
183
184			public function testAvailableStock()
185			{
186			// creamos el producto
187			$product = $this->getRandomProduct();
188			$this->assertTrue($product->save(), 'product-cant-save');
189
190			// añadimos stock
191			$stock = new Stock();
192			$stock->idproducto = $product->idproducto;
193			$stock->referencia = $product->referencia;
194			$stock->cantidad = 10;
195			$stock->reservada = 5;
196			$this->assertTrue($stock->save(), 'stock-cant-save');
197
198			// comprobamos
199			$this->assertTrue($stock->disponible < $stock->cantidad, 'stock-available-wrong');
200			$this->assertEquals(5, $stock->disponible);
201
202			// eliminamos
203			$this->assertTrue($stock->delete(), 'stock-cant-delete');
204			$this->assertTrue($product->delete(), 'product-cant-delete');
205			}
206
207			public function testNegativeQuantity()
208			{
209			// creamos el producto
210			$product = $this->getRandomProduct();
211			$this->assertTrue($product->save(), 'product-cant-save');
212
213			// añadimos stock
214			$stock = new Stock();
215			$stock->idproducto = $product->idproducto;
216			$stock->referencia = $product->referencia;
217			$stock->cantidad = -10;
218			$this->assertTrue($stock->save(), 'stock-cant-save');
219
220			// comprobamos
221			$this->assertEquals(0, $stock->cantidad);
222
223			// eliminamos
224			$this->assertTrue($stock->delete(), 'stock-cant-delete');
225			$this->assertTrue($product->delete(), 'product-cant-delete');
226			}
227
228			public function testNegativeAvailable()
229			{
230			// creamos el producto
231			$product = $this->getRandomProduct();
232			$this->assertTrue($product->save(), 'product-cant-save');
233
234			// añadimos stock
235			$stock = new Stock();
236			$stock->idproducto = $product->idproducto;
237			$stock->referencia = $product->referencia;
238			$stock->cantidad = 2;
239			$stock->reservada = 10;
240			$this->assertTrue($stock->save(), 'stock-cant-save');
241
242			// comprobamos
243			$this->assertEquals(0, $stock->cantidad);
244
245			// eliminamos
246			$this->assertTrue($stock->delete(), 'stock-cant-delete');
247			$this->assertTrue($product->delete(), 'product-cant-delete');
248			}
249
250			private function getRandomProduct(): Producto
251			{
252			$num = mt_rand(1, 9999);
253			$product = new Producto();
254			$product->referencia = 'test' . $num;
255			$product->descripcion = 'Test Product ' . $num;
256			return $product;
257			}
258
259			private function getRandomWarehouse(): Almacen
260			{
261			$warehouse = new Almacen();
262			$warehouse->nombre = 'Warehouse ' . mt_rand(1, 99);
263			return $warehouse;
264			}
265
266			protected function tearDown()
267			{
268			$this->logErrors();
269			}
270			}
271

NeoRazorX / facturascripts

Push — master ( 29ee7d...cd8ddc )

StockTest::testNegativeQuantity() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like