In Magento 1 konnte ich eine Datei erstellen, in der ich nur die Mage_Core_Model_AppKlasse instanziieren musste , und dann meinen "schmutzigen" Code zu Testzwecken hinzufügen.
So etwas in der Art test.php:

<?php
//some settings
error_reporting(E_ALL | E_STRICT); 
define('MAGENTO_ROOT', getcwd()); 
$mageFilename = MAGENTO_ROOT . '/app/Mage.php'; 
require_once $mageFilename; 
Mage::setIsDeveloperMode(true); 
ini_set('display_errors', 1); 
umask(0);
//instantiate the app model
Mage::app(); 
//my toy code in here.

Dann konnte ich test.phpden Browser aufrufen und sehen, was ich tue.

Wie kann ich dasselbe für Magento 2 tun?

Basierend auf der Antwort von @ Flyingmana habe ich ein wenig gegraben und eine Lösung gefunden. Es scheint, für mich zu arbeiten.
Erst meine Lösung, dann ein paar Erklärungen.
Ich habe eine Datei test.phpim Stammverzeichnis meiner Magento-Instanz erstellt.

<?php
require __DIR__ . '/app/bootstrap.php';
$bootstrap = \Magento\Framework\App\Bootstrap::create(BP, $_SERVER);
/** @var \Magento\Framework\App\Http $app */
$app = $bootstrap->createApplication('TestApp');
$bootstrap->run($app);

Dann habe ich eine Datei erstellt, TestApp.phpdie an derselben Stelle wie dieser Inhalt aufgerufen wird.

<?php
class TestApp
    extends \Magento\Framework\App\Http
    implements \Magento\Framework\AppInterface {
    public function launch()
    {
        //dirty code goes here. 
        //the example below just prints a class name
        echo get_class($this->_objectManager->create('\Magento\Catalog\Model\Category'));
        //the method must end with this line
        return $this->_response;
    }

    public function catchException(\Magento\Framework\App\Bootstrap $bootstrap, \Exception $exception)
    {
        return false;
    }

}

Jetzt kann ich einfach test.phpden Browser aufrufen und alles, was in TestApp :: launch () steht, wird ausgeführt.

Nun, warum das so ist:
Die Methode createApplicationaus der Bootstrap-Klasse ist der wichtigste Teil. Es wird eine Instanz einer Anwendungsklasse erstellt. Die Methode createApplicationerwartet eine Implementierung der \Magento\Framework\AppInterface, die 2 Methoden enthält.
Also habe ich meine eigene Klasse erstellt TestApp, die diese Schnittstelle implementiert. Ich habe die Methode catchExceptionzurückgeben falseimmer , weil ich möchte , dass meine App nicht um Ausnahmen zu behandeln. Falls etwas nicht stimmt, drucken Sie es einfach auf dem Bildschirm aus.
Dann habe ich die Methode implementiert launch. Dieser wird von angerufen \Magento\Framework\App\Bootstrap::run. Diese runMethode führt fast das gleiche aus, unabhängig davon, welche Anwendung als Parameter übergeben wurde.
Das einzige, was von der Anwendung abhängt, ist diese Zeile:

$response = $application->launch();

Dies bedeutet, dass der Aufruf \Magento\Framework\App\Bootstrap::rundas Magento-Env auslöst (vielleicht machen Sie ein paar andere verrückte Sachen ... Ich habe noch nicht alles überprüft) und dann die launchMethode aus der Anwendung aufruft .
Aus diesem Grund müssen Sie Ihren gesamten Dirty-Code in diese Methode einfügen.
Dann werden die \Magento\Framework\App\Bootstrap::runAufrufe $response->sendResponse();where $responseist, was die launchMethode zurückgibt.
Deshalb return $this->_response;wird es gebraucht. Es wird nur eine leere Antwort zurückgegeben.

Ich habe meine App-Klasse erweitert, \Magento\Framework\App\Httpsodass ich bereits Anforderungs- und Antwortparameter (und andere) habe, aber Sie können Ihre Klasse dazu bringen, nichts zu erweitern. Dann müssen Sie den Konstruktor aus der \Magento\Framework\App\HttpKlasse kopieren . Fügen Sie ggf. weitere Parameter im Konstruktor hinzu.

Für schnelle / kurze / schmutzige Tests habe ich Folgendes verwendet:

use Magento\Framework\App\Bootstrap;
require __DIR__ . '/../app/bootstrap.php';

$bootstrap = Bootstrap::create(BP, $_SERVER);

$obj = $bootstrap->getObjectManager();

$state = $obj->get('Magento\Framework\App\State');
$state->setAreaCode('frontend');

$quote = $obj->get('Magento\Checkout\Model\Session')->getQuote()->load(1);
print_r($quote->getOrigData());

Aufgrund der Antwort von @ Marius habe ich mir das ausgedacht .

Es funktioniert sowohl über die Kommandozeile als auch über den Browser, was ich nützlich finde.

Hier ist ein Beispielskript zum programmgesteuerten Löschen einer Kategorie.

scripts/abstract.php

<?php
use \Magento\Framework\AppInterface as AppInterface;
use \Magento\Framework\App\Http as Http;

use Magento\Framework\ObjectManager\ConfigLoaderInterface;
use Magento\Framework\App\Request\Http as RequestHttp;
use Magento\Framework\App\Response\Http as ResponseHttp;
use Magento\Framework\Event;
use Magento\Framework\Filesystem;
use Magento\Framework\App\AreaList as AreaList;
use Magento\Framework\App\State as State;

abstract class AbstractApp implements AppInterface
{
    public function __construct(
        \Magento\Framework\ObjectManagerInterface $objectManager,
        Event\Manager $eventManager,
        AreaList $areaList,
        RequestHttp $request,
        ResponseHttp $response,
        ConfigLoaderInterface $configLoader,
        State $state,
        Filesystem $filesystem,
        \Magento\Framework\Registry $registry
    ) {
        $this->_objectManager = $objectManager;
        $this->_eventManager = $eventManager;
        $this->_areaList = $areaList;
        $this->_request = $request;
        $this->_response = $response;
        $this->_configLoader = $configLoader;
        $this->_state = $state;
        $this->_filesystem = $filesystem;
        $this->registry = $registry;
    }

    public function launch()
    {
        $this->run();
        return $this->_response;
    }

    abstract public function run();

    public function catchException(\Magento\Framework\App\Bootstrap $bootstrap, \Exception $exception)
    {
        return false;
    }
}

scripts/delete-category.php

<?php
require dirname(__FILE__) . '/../app/bootstrap.php';
$bootstrap = \Magento\Framework\App\Bootstrap::create(BP, $_SERVER);
require dirname(__FILE__) . '/abstract.php';

class CreateCategoriesApp extends AbstractApp
{

    public function run()
    {
        $this->_objectManager->get('Magento\Framework\Registry')
            ->register('isSecureArea', true);

        $category = $this->_objectManager->create('\Magento\Catalog\Model\Category');
        $category = $category->load(343);

        $category->delete();
    }
}

/** @var \Magento\Framework\App\Http $app */
$app = $bootstrap->createApplication('CreateCategoriesApp');
$bootstrap->run($app);

Dann lasse ich es einfach so laufen php scripts/delete-category.php

Auf Anfrage ein sehr kurzes Beispiel, wie Sie einen Test schreiben können (ohne ihn in Ihrer Ordnererweiterungsstruktur abzulegen). Leider ist dies alles Kommandozeile und nicht zum Verzehr über einen Browser.

Erstellen Sie die Datei

dev/tests/unit/quicktest.php

mit

<?php

class QuickTest extends \PHPUnit_Framework_TestCase
{
    public function testExample()
    {
        //instantiate your class
        $context = new Magento\Framework\Object();

        $context->setData('param', 'value');

        //test whatever you want to test
        $this->assertEquals('value', $context->getData('param'));

        //you could even output to console
        echo $context->getData('param');

    }
}

dann aus dem Verzeichnis dev/tests/unit/laufen , phpunit quicktest.phpdie Ihren Code ausgeführt werden. Dies alles funktioniert, da die Datei dev/tests/unit/phpunit.xml.distautomatisch geladen wird und die Umgebung vorbereitet.

In vielen Fällen müssen Sie möglicherweise Eingaben an den Konstruktor der Klassen senden. In den vorhandenen Tests unter finden Sie dev/tests/unit/testsuite/weitere Beispiele, wie dies aussehen könnte, einschließlich der Verspottung von Objekten.

Hier ist eine bessere Möglichkeit, als sich in das Testsystem einzuklinken: Verwenden Sie die Befehlszeilenschnittstelle von Magento 2.

Das bedeutet, dass Sie Ihren Sandbox-Code in ein tatsächliches Modul integrieren müssen (oder zu diesem Zweck eines erstellen müssen), aber Sie sollten dies trotzdem tun.

Sobald Sie Ihr Modul eingerichtet haben , ist das Hinzufügen eines Befehls ziemlich einfach. Alles, was Sie brauchen, ist die Klasse und DI, um sie zu registrieren.

1. {module} /etc/di.xml

<?xml version="1.0"?>
<config xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:noNamespaceSchemaLocation="urn:magento:framework:ObjectManager/etc/config.xsd">
    <type name="Magento\Framework\Console\CommandList">
        <arguments>
            <argument name="commands" xsi:type="array">
                <item name="greeting_command" xsi:type="object">Magento\CommandExample\Console\Command\GreetingCommand</item>
            </argument>
        </arguments>
    </type>
</config>

2. {module} /Console/Command/GreetingCommand.php

<?php

namespace Magento\CommandExample\Console\Command;

use Symfony\Component\Console\Command\Command;
use Symfony\Component\Console\Input\InputInterface;
use Symfony\Component\Console\Output\OutputInterface;

/**
 * Class GreetingCommand
 */
class GreetingCommand extends Command
{
    /**
     * {@inheritdoc}
     */
    protected function configure()
    {
        $this->setName('example:greeting')
             ->setDescription('Greeting command');

        parent::configure();
    }

    /**
     * {@inheritdoc}
     */
    protected function execute(InputInterface $input, OutputInterface $output)
    {
        $output->writeln('<info>Hello world!</info>');
    }
}

Beispiel abgeleitet von https://github.com/magento/magento2-samples/tree/master/sample-module-command - ein vollständiges Modul mit dieser Funktionalität finden Sie dort. Es gibt weniger triviale Beispiele .

Konventionell sollte Ihre Befehlsklasse immer in sein {module}/Console/Commandund mit enden Command.php.

Sobald man diese zwei Bits von Code (und gerötet Magento Cache, etc.) hinzugefügt haben, führen Sie Ihren Befehl mit Namen in SSH: php bin/magento example:greeting.

In diesem Kontext können Sie die Abhängigkeitsinjektion verwenden, sodass Sie jeden Code ausführen können, den Sie möchten execute().

Diese Benutzeroberfläche basiert auf der Symfony- Konsolenkomponente , sodass Sie auch vollen Zugriff auf alle Funktionen haben, einschließlich Optionen / Argumente , Tabellen und einfacher Fortschrittsbalken .

Wenn Sie beim Einrichten Ihres Befehls oder Ihrer Optionen auf Probleme stoßen, können Sie normalerweise den Befehl 'list' ausführen, um einen besseren Überblick über die Fehlerursache zu erhalten: php bin/magento list

Genießen.

Der wichtige Teil ist der \Magento\Framework\App\Bootstrap::create

Da die Bootstrap::init()Methode privat ist und viele wichtige Dinge vorkommen, werden öffentliche Methoden benötigt, die sie aufrufen.

Das ist auf der einen Seite die createApplication()und folgende run()Methode, aber auch die getDirList()und getObjectManager()Methode, die beide kein Argument benötigen.

Eine Anwendung wird also nicht benötigt, die Nachteile sind, dass der Fehlerhandler nicht initialisiert wird.

Möglicherweise nicht zum Thema gehörend, aber ich verwende immer die Contacts-Index-Controller-Datei in Magento 1, um Dinge zu testen (IndexAction-Methode). Es ist so einfach wie das Aufrufen von example.com/contacts. Sie müssen nur sicherstellen, dass diese Änderungen nicht übernommen werden.

Ich bin sicher, dass Sie in Magento 2 etwas Ähnliches tun können. Sie müssen keine neue Datei mit dem Bootstrap-Code erstellen.

Diese Antwort ist eine leichte Modifikation der obigen Antwort von Marius

Denn in Magento 2.1 kam der Fehler wie Area code not setbei der Verwendung dieses Codes.So the intension of this answer is to fix that error on Magento 2.1

Um diesen Fehler zu beheben, müssen Sie den Bereich in Ihrem Netzwerk definieren test.php file. (siehe die modifizierte Datei unten).

<?php
require __DIR__ . '/app/bootstrap.php';
$bootstrap = \Magento\Framework\App\Bootstrap::create(BP, $_SERVER);
$obj = $bootstrap->getObjectManager();

$state = $obj->get('Magento\Framework\App\State');
$state->setAreaCode('frontend');
/** @var \Magento\Framework\App\Http $app */
$app = $bootstrap->createApplication('TestApp');
$bootstrap->run($app);

Und die TestApp.phpDatei bleibt gleich.

<?php

class TestApp
    extends \Magento\Framework\App\Http
    implements \Magento\Framework\AppInterface {
    public function launch()
    {
        //dirty code goes here.
        $objectManager = \Magento\Framework\App\ObjectManager::getInstance();
        $product = $objectManager->get('Magento\Catalog\Model\Product')->load(71);
        var_dump($product->getData());

        return $this->_response;
    }

    public function catchException(\Magento\Framework\App\Bootstrap $bootstrap, \Exception $exception)
    {
        return false;
    }

}

Sie können Skripte auf Magento-Root ausführen, indem Sie den folgenden Code hinzufügen, und Bootstrap wird mitgeliefert.

ini_set('display_errors', 1);
ini_set('max_execution_time', 0);
ini_set("memory_limit", "-1");
set_time_limit(0);
error_reporting(E_ALL);
require './app/bootstrap.php';
$bootstrap = \Magento\Framework\App\Bootstrap::create(BP, $_SERVER);
$objectManager = $bootstrap->getObjectManager();
$state = $objectManager->get('Magento\Framework\App\State');
$state->setAreaCode('admin');

Hoffe das wird hilfreich sein.

Sie können das Direktskript von Magento 2 root aus mit dem folgenden Code ausführen. Erstellen Sie eine neue Datei im Magento 2-Stammverzeichnis, fügen Sie diesen Code hinzu und fügen Sie anschließend Ihr Skript in die Datei ein.

<?php
    use Magento\Framework\App\Bootstrap;
    include('app/bootstrap.php');
    $bootstrap = Bootstrap::create(BP, $_SERVER);

    $objectManager = $bootstrap->getObjectManager();

    $state = $objectManager->get('Magento\Framework\App\State');
    $state->setAreaCode('frontend');

Folgendes habe ich getan, um Magento außerhalb des Magento-Verzeichnisses in mein benutzerdefiniertes Skript zu initialisieren.

//Required to include Magento functions.
$magento_dir "your/path/to/the/magento/installation/directory/";
require $magento_dir . 'app/bootstrap.php';
$bootstrap = \Magento\Framework\App\Bootstrap::create(BP, $_SERVER);
//$app = $bootstrap->createApplication('Magento\Framework\App\Http');
$app = $bootstrap->createApplication('MyClass');
$bootstrap->run($app);

Dies ist der empfohlene Weg gemäß den Magento-Dokumenten. http://devdocs.magento.com/guides/v2.0/config-guide/bootstrap/magento-bootstrap.html