File: D:/HostingSpaces/SBogers10/shop.komma.nl/tests/Unit/OrderTest.php
<?php
//TODO Update when shop v1 is ready
//namespace App\Tests\Unit;
//
//use App\Orders\Kms\OrderService;
//use App\Orders\Mail\OrderStatusUpdatedCustomer;
//use App\Orders\Models\Order;
//use App\Orders\Product\OrderedProduct;
//use App\Orders\ProductComposite\OrderedProductComposite;
//use App\Orders\ProductGroup\OrderedProductGroup;
//use App\Payment\Events\TransactionChanged;
//use App\Payment\Transaction;
//use App\Payment\TransactionStatus;
//use App\Products\Product\Product;
//use App\Products\Product\ProductModelService;
//use App\Products\ProductComposite\ProductComposite;
//use App\Products\ProductComposite\ProductCompositeModelService;
//use App\Products\ProductGroup\ProductGroup;
//use App\Products\ProductGroup\ProductGroupModelService;
//use App\Products\ProductGroupBehaviour\ProductGroupBehaviour;
//use Illuminate\Foundation\Testing\DatabaseTransactions;
//use Tests\TestCase;
//use Illuminate\Mail\Mailable;
//use Illuminate\Support\Collection;
//use Illuminate\Support\Facades\Mail;
//
//class OrderTest extends TestCase
//{
// use DatabaseTransactions; //NOT Possible because of how the testManualPayment test works
//
// /**
// * @group orderedProducts
// */
// public function testOrderedProductCreation()
// {
// $productService = new ProductModelService();
//
// $product = factory(Product::class)->create();
// $this->assertInstanceOf(Product::class, $product);
// /** @var Product $product */
//
// $this->assertDatabaseHas('products', [PS
// 'price' => $product->price,
// 'stock_keeping_unit' => $product->stock_keeping_unit,
// ]);
//
// $order = factory(Order::class)->create();
//
// /** @var OrderedProduct $orderedProduct */
// $orderedProduct = $productService->createOrderedProductFromProduct($product, $order, 1);
// $this->assertInstanceOf(OrderedProduct::class, $orderedProduct);
//
//
// $this->assertEquals($product->price, $orderedProduct->price);
// $this->assertEquals($product->stock_keeping_unit, $orderedProduct->stock_keeping_unit);
//
// $orderService = new OrderService();
// $orderService->destroyForModel($order);
// $order->delete();
//
// $orderedProduct->delete();
// $product->delete();
// }
//
// /**
// * @group orderedProducts
// */
// public function testOrderedGroupCreation()
// {
// $productService = new ProductGroupModelService();
//
// $group = factory(ProductGroup::class)->make();
// $behaviour = factory(ProductGroupBehaviour::class)->create();
//
// $this->assertInstanceOf(ProductGroup::class, $group);
// $this->assertInstanceOf(ProductGroupBehaviour::class, $behaviour);
// /** @var ProductGroup $group */
// /** @var ProductGroupBehaviour $behaviour */
//
// $group->productGroupBehaviour()->associate($behaviour);
// $group->save();
//
// $this->assertDatabaseHas('product_groups', [
// 'id' => $group->id,
// 'active' => $group->active,
// ]);
//
// $order = factory(Order::class)->create();
//
// /** @var OrderedProductGroup $orderedProductGroup */
// $orderedProductGroup = $productService->createOrderedProductGroupFromProductGroup($group, $order, 1);
//
// $this->assertInstanceOf(OrderedProductGroup::class, $orderedProductGroup);
//
// $this->assertEquals($group->active, $orderedProductGroup->active);
//
// $orderService = new OrderService();
// $orderService->destroyForModel($order);
// $order->delete();
// $group->delete();
// $orderedProductGroup->orderedProducts()->delete();
// $orderedProductGroup->delete();
// }
//
// /**
// * @group orderedProducts
// */
// public function testOrderedCompositeCreation()
// {
// $productCompositeService = new ProductCompositeModelService();
//
// $productComposite = factory(ProductComposite::class)->make();
// $productGroup = factory(ProductGroup::class)->make();
// $behaviour = factory(ProductGroupBehaviour::class)->create();
//
// $this->assertInstanceOf(ProductGroup::class, $productGroup);
// $this->assertInstanceOf(ProductGroupBehaviour::class, $behaviour);
// $this->assertInstanceOf(ProductComposite::class, $productComposite);
// /** @var ProductGroup $productGroup */
// /** @var ProductGroupBehaviour $behaviour */
// /** @var ProductComposite $productComposite */
//
// $productGroup->productGroupBehaviour()->associate($behaviour);
// $productGroup->save();
//
//
// $productComposite->save();
// $productComposite->groups()->attach($productGroup);
// $productComposite->save();
//
//
// $this->assertDatabaseHas('product_composites', [
// 'active' => $productComposite->active,
// ]);
//
// $order = factory(Order::class)->create();
//
// /** @var OrderedProduct $orderedComposite */
// $orderedComposite = $productCompositeService->createOrderedProductCompositeProductComposite($productComposite, $order, 1);
//
// $this->assertInstanceOf(OrderedProductComposite::class, $orderedComposite);
//
// $this->assertEquals($productComposite->name, $orderedComposite->name);
// $this->assertEquals($productComposite->active, $orderedComposite->active);
//
// $orderService = new OrderService();
// $orderService->destroyForModel($order);
// $order->delete();
//
// $orderedComposite->delete();
// }
//
// /**
// * @group orderedProducts
// */
// public function testOrderedProductHistory()
// {
// $productService = new ProductModelService();
//
// $product = factory(Product::class)->create();
//
// $order = factory(Order::class)->create();
//
// /** @var OrderedProduct $orderedProduct */
// $orderedProduct = $productService->createOrderedProductFromProduct($product, $order, 1);
// $this->assertInstanceOf(OrderedProduct::class, $orderedProduct);
//
//
// $originalPrice = $product->price;
// $newPrice = $originalPrice + 10000;
//
// $product->price = $newPrice;
// $product->save();
//
// $this->assertNotEquals($product->price, $orderedProduct->price);
// $this->assertEquals($product->price, $newPrice);
// $this->assertEquals($orderedProduct->price, $originalPrice);
//
// $orderService = new OrderService();
// $orderService->destroyForModel($order);
// $order->delete();
//
// $product->delete();
// }
//
// /**
// * @group orderedProducts
// */
// public function testOrderedGroupHistory()
// {
// $productGroupService = new ProductGroupModelService();
//
// $productsCount = 3;
//
// /** @var Collection $products */
// $products = factory(Product::class, $productsCount)->create();
// $products = $products->keyBy('id'); //Now we can use ->get(12) on the products collection to get the product with id 12
// $group = factory(ProductGroup::class)->make(); /** @var ProductGroup $group */
// $behaviour = factory(ProductGroupBehaviour::class)->create();
//
// $group->productGroupBehaviour()->associate($behaviour);
// $group->save();
// $group->products()->saveMany($products);
//
// $order = factory(Order::class)->create();
//
// /** @var OrderedProductGroup $orderedProductGroup */
// $orderedProductGroup = $productGroupService->createOrderedProductGroupFromProductGroup($group, $order, 1);
//
//// echo PHP_EOL.'Testing ordered product group history:';
//// echo PHP_EOL.'Original product prices:';
//// $products->each(function(Product $product) {
//// echo PHP_EOL.$product->id.' => '.$product->price;
//// });
////
//// echo PHP_EOL.'Ordered product prices';
//// $orderedProductGroup->orderedProducts()->get()->each(function(OrderedProduct $orderedProduct) {
//// echo PHP_EOL.$orderedProduct->id.' => '.$orderedProduct->price.' (Original product price: '.$orderedProduct->product()->first()->price.')';
//// });
//
// //Edit the products prices. The ordered products still have the same price after the loop
// $add = 1000;
// $products->each(function(Product $product) use ($add) {
// $product->price += $add;
// $product->save();
// });
//
//// echo PHP_EOL.'Modified product prices';
//// $products->each(function(Product $product) {
//// echo PHP_EOL.$product->id.' => '.$product->price;
//// });
//
// $orderedProductGroupOriginalProducts = $orderedProductGroup->products()->get();
// $this->assertEquals($productsCount, $orderedProductGroupOriginalProducts->count());
//
// $orderedProductGroupOriginalProducts->each(function(Product $product) use ($products) {
// $originalProduct = $products->get($product->id);
// $this->assertNotNull($originalProduct); //Checks that ordered products original products id's are in the products collection we started with
// });
//
// $orderedProductGroup->orderedProducts()->get()->each(function(OrderedProduct $orderedProduct) use ($products, $add) {
// $originalProduct = $orderedProduct->product()->first();
// $this->assertNotNull($originalProduct);
//
// $this->assertNotEquals($orderedProduct->price, $originalProduct->price);
// $this->assertEquals($orderedProduct->price, $originalProduct->price - $add);
// });
//
// $orderService = new OrderService();
// $orderService->destroyForModel($order);
// $order->delete();
//
// Product::destroy($products->pluck('id'));
// $group->delete();
// }
//
// /**
// * @group orderedProducts
// */
// public function testOrderedCompositeHistory()
// {
// $productCompositeService = new ProductCompositeModelService();
//
// $productsCount = 3;
//
// /** @var \Illuminate\Database\Eloquent\Collection $products */
// $products = factory(Product::class, $productsCount)->create();
// $products = $products->keyBy('id'); //Now we can use ->get(12) on the products collection to get the product with id 12
// $group = factory(ProductGroup::class)->make(); /** @var ProductGroup $group */
// $behaviour = factory(ProductGroupBehaviour::class)->create();
//
// $group->productGroupBehaviour()->associate($behaviour);
// $group->save();
// $group->products()->saveMany($products);
//
// /** @var ProductComposite $composite */
// $composite = factory(ProductComposite::class)->create();
// $composite->groups()->save($group);
//
//
// $order = factory(Order::class)->create();
//
// /** @var OrderedProductComposite $orderedComposite */
// $orderedComposite = $productCompositeService->createOrderedProductCompositeProductComposite($composite, $order, 1);
//
// //Edit the products prices. The ordered products still have the same price after the loop
// $add = 1000;
// $products->each(function(Product $product) use ($add) {
// $product->price += $add;
// $product->save();
// });
//
// //Check that the products count is the same as the orignal product count in the orderedProductComposite
// /** @var ProductGroup|null $orderedProductCompositeOriginalGroup */
// $orderedProductCompositeOriginalGroup = $orderedComposite->groups()->first();
// $orderedProductCompositeOriginalProducts = $orderedProductCompositeOriginalGroup->products()->get();
// $this->assertEquals($productsCount, $orderedProductCompositeOriginalProducts->count());
//
// foreach($orderedProductCompositeOriginalProducts as $product) {
// $originalProduct = $products->get($product->id);
// $this->assertNotNull($originalProduct); //Checks that ordered products original products id's are in the products collection we started with
// };
//
// /** @var OrderedProductGroup|null $orderedGroup */
// $orderedGroup = $orderedComposite->orderedGroups()->first();
// $this->assertNotNull($orderedGroup);
// $this->assertCount(1, $orderedComposite->orderedGroups()->get());
//
// $orderedProducts = $orderedGroup->orderedProducts()->get();
// foreach($orderedProducts as $orderedProduct) {
// $originalProduct = $orderedProduct->product()->first();
// $this->assertNotNull($originalProduct);
//
// $this->assertNotEquals($orderedProduct->price, $originalProduct->price);
// //The original product was 1000 cents more than the ordered one. So you can also say that the orderedProduct->price + 1000 cents is the same as the original product price
// $this->assertEquals($orderedProduct->price + $add, $originalProduct->price);
// };
//
// $orderService = new OrderService();
// $orderService->destroyForModel($order);
// $order->delete();
//
// Product::destroy($products->pluck('id'));
// $group->delete();
// $composite->delete();
// }
//
// /**
// * @group orderedProducts
// */
// public function testManualPayment()
// {
// Mail::fake();
//
// // Assert that no mailables were sent...
// Mail::assertNothingSent();
//
// //Create an order with a customer and a transaction
// /** @var Order $order */
// $order = factory(Order::class)->create();
//
// /** @var Transaction $transaction */
// $transaction = factory(Transaction::class)->make();
// $transaction->payment_link = 'http://localhost:8000/fakepsp/'.$order->id;
// $order->transactions()->save($transaction);
//
// //Cancel the transaction and send a transactionChanged event like PSP Adapters do.
// //This causes the TransactionChanged event listener to kick in and send our user a mail allowing them to still pay their order IF they would like to
// $transaction->status = TransactionStatus::CANCELED_CUSTOMER;
// $transactionChangedEvent = new TransactionChanged($transaction);
// $transaction->save();
// event($transactionChangedEvent);
//
// Mail::assertSent(OrderStatusUpdatedCustomer::class,
// /** @param Mailable|OrderStatusUpdatedCustomer $mail */
// function ($mail) use ($order, $transaction) {
// $mail->build();
// $customerWasCorrect = $mail->hasTo($order->customer->email);
// $paymentLink = $mail->viewData['button_url'];
// $response = $this->get($paymentLink);
// $completePaymentTextVisible = $response->assertSeeText(__('shop/checkout.complete_payment'));
// $checkoutTextVisible = $response->assertSeeText(__('shop/checkout.checkout'));
// $response->assertSee($transaction->payment_link);
// return $completePaymentTextVisible && $checkoutTextVisible && $customerWasCorrect; //Consider the mail as sent when the correct customer was set and the link in it resolves to a page with the correct texts.
// }
// );
//
// $orderService = new OrderService();
// $orderService->destroyForModel($order);
// $order->delete();
// }
//}