modified Login logic

Author: p123-stack

src/Neo4jQueryAPI.php

@@ -4,6 +4,8 @@
 
 use Exception;
 use GuzzleHttp\Client;
+use Neo4j\QueryAPI\Objects\Auth;
+use Neo4j\QueryAPI\Objects\Authentication;
 use Neo4j\QueryAPI\Objects\ProfiledQueryPlanArguments;
 use Neo4j\QueryAPI\Objects\ResultCounters;
 use Neo4j\QueryAPI\Objects\ProfiledQueryPlan;
@@ -24,13 +26,13 @@ public function __construct(Client $client)
         $this->client = $client;
     }
 
-    public static function login(string $address, string $username, string $password): self
+    public static function login(string $address, Authentication $auth): self
     {
         $client = new Client([
             'base_uri' => rtrim($address, '/'),
             'timeout' => 10.0,
             'headers' => [
-                'Authorization' => 'Basic ' . base64_encode("$username:$password"),
+                'Authorization' => $auth->getHeader(),
                 'Content-Type' => 'application/vnd.neo4j.query',
                 'Accept' => 'application/vnd.neo4j.query',
             ],
@@ -39,6 +41,7 @@ public static function login(string $address, string $username, string $password
         return new self($client);
     }
 
+
     /**
      * @throws Neo4jException
      * @throws RequestExceptionInterface

src/Objects/Authentication.php

@@ -0,0 +1,56 @@
+<?php
+
+namespace Neo4j\QueryAPI\Objects;
+
+use InvalidArgumentException;
+
+class Authentication
+{
+    private string $header;
+    private string $type;
+
+    private function __construct(string $header, string $type)
+    {
+        $this->header = $header;
+        $this->type = $type;
+    }
+
+    public static function request(string $username = null, string $password = null, string $token = null): self
+    {
+        if ($token !== null) {
+            return self::bearer($token);
+        }
+        if ($username === null) {
+            $username = getenv('NEO4J_USERNAME');
+        }
+
+        if ($password === null) {
+            $password = getenv('NEO4J_PASSWORD');
+        }
+        if ($username !== null && $password !== null) {
+            return self::basic($username, $password);
+        }
+
+        throw new InvalidArgumentException("Both username and password cannot be null.");
+    }
+
+    private static function basic(string $username, string $password): self
+    {
+        return new self("Basic " . base64_encode("$username:$password"), 'Basic');
+    }
+
+    private static function bearer(string $token): self
+    {
+        return new self("Bearer $token", 'Bearer');
+    }
+
+    public function getHeader(): string
+    {
+        return $this->header; // Return the header string directly
+    }
+
+    public function getType(): string
+    {
+        return $this->type;
+    }
+}

src/Objects/php your-script.php

@@ -0,0 +1,19 @@
+<?php
+
+use Neo4j\QueryAPI\Objects\Authentication;
+require_once 'Authentication.php'; // Assuming your Authentication class is in Authentication.php
+
+// Using Bearer Token Authentication
+$authBearer = Authentication::create([
+    'token' => 'yourBearerToken'
+]);
+
+print_r($authBearer->getHeader());
+
+// Using Basic Authentication
+$authBasic = Authentication::create([
+    'username' => '',
+    'password' => ''
+]);
+
+print_r($authBasic->getHeader());

tests/Integration/Neo4jQueryAPIIntegrationTest.php

@@ -9,6 +9,7 @@
 use GuzzleHttp\Psr7\Response;
 use Neo4j\QueryAPI\Exception\Neo4jException;
 use Neo4j\QueryAPI\Neo4jQueryAPI;
+use Neo4j\QueryAPI\Objects\Authentication;
 use Neo4j\QueryAPI\Objects\ProfiledQueryPlan;
 use Neo4j\QueryAPI\Objects\Bookmarks;
 use Neo4j\QueryAPI\Objects\ResultCounters;
@@ -37,20 +38,26 @@ public function setUp(): void
 
     private function initializeApi(): Neo4jQueryAPI
     {
+        $auth = Authentication::request();  // Automatically determines basic or bearer
         return Neo4jQueryAPI::login(
             getenv('NEO4J_ADDRESS'),
-            getenv('NEO4J_USERNAME'),
-            getenv('NEO4J_PASSWORD')
+            $auth
         );
     }
 
+
+
     public function testCounters(): void
     {
         $result = $this->api->run('CREATE (x:Node {hello: "world"})');
 
         $this->assertEquals(1, $result->getQueryCounters()->getNodesCreated());
     }
 
+    /**
+     * @throws Neo4jException
+     * @throws RequestExceptionInterface
+     */
     public function testCreateBookmarks(): void
     {
         $result = $this->api->run(cypher: 'CREATE (x:Node {hello: "world"})');

tests/Unit/AuthenticationTest.php

@@ -0,0 +1,67 @@
+<?php
+
+namespace Neo4j\QueryAPI\Tests\Unit;
+
+use Neo4j\QueryAPI\Objects\Authentication;
+use PHPUnit\Framework\TestCase;
+use InvalidArgumentException;
+
+class AuthenticationTest extends TestCase
+{
+    public function testBearerToken(): void
+    {
+        // Mock a bearer token
+        $mockToken = 'mocked_bearer_token';
+
+        // Create an Authentication instance with the bearer token
+        $auth = Authentication::request(token: $mockToken);
+
+        // Assert that the Authorization header is correct
+        $this->assertEquals("Bearer $mockToken", $auth->getHeader(), 'Bearer token mismatch.');
+        $this->assertEquals('Bearer', $auth->getType(), 'Type should be Bearer.');
+    }
+
+    public function testBasicAuthentication(): void
+    {
+        // Mock username and password
+        $mockUsername = 'mockUser';
+        $mockPassword = 'mockPass';
+
+        // Create an Authentication instance with username and password
+        $auth = Authentication::request($mockUsername, $mockPassword);
+
+        // Assert that the Authorization header is correct
+        $expectedHeader = 'Basic ' . base64_encode("$mockUsername:$mockPassword");
+        $this->assertEquals($expectedHeader, $auth->getHeader(), 'Basic authentication header mismatch.');
+        $this->assertEquals('Basic', $auth->getType(), 'Type should be Basic.');
+    }
+
+    public function testFallbackToEnvironmentVariables(): void
+    {
+        // Mock environment variables
+        putenv('NEO4J_USERNAME=mockEnvUser');
+        putenv('NEO4J_PASSWORD=mockEnvPass');
+
+        // Create an Authentication instance with environment variables
+        $auth = Authentication::request();
+
+        // Assert that the Authorization header is correct
+        $expectedHeader = 'Basic ' . base64_encode("mockEnvUser:mockEnvPass");
+        $this->assertEquals($expectedHeader, $auth->getHeader(), 'Basic authentication with environment variables mismatch.');
+        $this->assertEquals('Basic', $auth->getType(), 'Type should be Basic.');
+
+        // Cleanup the environment variables
+        putenv('NEO4J_USERNAME');
+        putenv('NEO4J_PASSWORD');
+    }
+
+    public function testInvalidArguments(): void
+    {
+        // Expect an exception when both username and password are null
+        $this->expectException(InvalidArgumentException::class);
+        $this->expectExceptionMessage('Both username and password cannot be null.');
+
+        // Attempt to create an Authentication instance without credentials
+        Authentication::request(null, null, null);
+    }
+}

tests/Unit/Neo4jQueryAPIUnitTest.php

@@ -8,6 +8,7 @@
 use GuzzleHttp\HandlerStack;
 use GuzzleHttp\Psr7\Response;
 use Neo4j\QueryAPI\Neo4jQueryAPI;
+use Neo4j\QueryAPI\Objects\Authentication;
 use Neo4j\QueryAPI\Objects\Bookmarks;
 use Neo4j\QueryAPI\Objects\ResultCounters;
 use Neo4j\QueryAPI\Results\ResultRow;
@@ -24,34 +25,47 @@ protected function setUp(): void
     {
         parent::setUp();
 
-        $this->address = getenv('NEO4J_ADDRESS');
-        $this->username = getenv('NEO4J_USERNAME');
-        $this->password = getenv('NEO4J_PASSWORD');
+        $this->address = getenv('NEO4J_ADDRESS') ;
+        $this->username = getenv('NEO4J_USERNAME') ;
+        $this->password = getenv('NEO4J_PASSWORD') ;
     }
 
     public function testCorrectClientSetup(): void
     {
-        $neo4jQueryAPI = Neo4jQueryAPI::login($this->address, $this->username, $this->password);
+        // Verify Authentication object creation
+        $authentication = Authentication::request($this->username, $this->password);
+        $expectedAuthHeader = 'Basic ' . base64_encode("{$this->username}:{$this->password}");
+        $this->assertEquals($expectedAuthHeader, $authentication->getHeader(), 'Authentication header mismatch.');
+
+        // Use the updated login method
+        $neo4jQueryAPI = Neo4jQueryAPI::login($this->address, $authentication);
 
         $this->assertInstanceOf(Neo4jQueryAPI::class, $neo4jQueryAPI);
 
+        // Use reflection to access private `client` property
         $clientReflection = new \ReflectionClass(Neo4jQueryAPI::class);
         $clientProperty = $clientReflection->getProperty('client');
+        // Ensure we can access private properties
         $client = $clientProperty->getValue($neo4jQueryAPI);
 
         $this->assertInstanceOf(Client::class, $client);
 
+        // Get the client's configuration and check headers
         $config = $client->getConfig();
         $this->assertEquals(rtrim($this->address, '/'), $config['base_uri']);
-        $this->assertEquals('Basic ' . base64_encode("{$this->username}:{$this->password}"), $config['headers']['Authorization']);
+        $this->assertArrayHasKey('Authorization', $config['headers'], 'Authorization header missing.');
+        $this->assertEquals($expectedAuthHeader, $config['headers']['Authorization'], 'Authorization header value mismatch.');
         $this->assertEquals('application/vnd.neo4j.query', $config['headers']['Content-Type']);
+        $this->assertEquals('application/vnd.neo4j.query', $config['headers']['Accept']);
     }
 
+
     /**
      * @throws GuzzleException
      */
     public function testRunSuccess(): void
     {
+        // Mock response for a successful query
         $mock = new MockHandler([
             new Response(200, ['X-Foo' => 'Bar'], '{"data": {"fields": ["hello"], "values": [[{"$type": "String", "_value": "world"}]]}}'),
         ]);