/** * Prepares the field to have a sequence. If $value is zero or not defined * a new auto-increment number will be "generated" for the collection of * the schema. The sequence generation is done by the SequenceService. * * @param int|null $value Value that will be evaluated. * * @return int */ public function sequence(int $value = null) { if ($value) { return $value; } return Ioc::make(SequenceService::class)->getNextValue($this->collection ?: $this->entityClass); }
public function testShouldCallMethodsPropertlywithFiveOrMoreArgument() { $container = m::mock(Container::class); $container->shouldReceive('method')->once()->with(1, 2, 3, 4, 5)->andReturn(true); Ioc::setContainer($container); Ioc::method(1, 2, 3, 4, 5); }
/** * Constructs a new Mongolid connection. It uses the same constructor * parameters as the original MongoDB\Client constructor. * * @see http://php.net/manual/en/mongodb-driver-manager.construct.php * * @param string $server The specified connection string. * @param array $options The mongodb client options. * @param array $driver_options The mongodb driver options when opening a connection. */ public function __construct(string $server = 'mongodb://localhost:27017', array $options = ['connect' => true], array $driver_options = []) { // In order to work with PHP arrays instead of with objects $driver_options['typeMap'] = ['array' => 'array', 'document' => 'array']; $this->findDefaultDatabase($server); $parameters = [$server, $options, $driver_options]; $this->rawManager = Ioc::make(Manager::class, $parameters); $this->rawConnection = Ioc::make(Client::class, $parameters); }
public function testShouldRegisterConnectorWithUsernameAndPassword() { // Set $provider = new MongolidServiceProvider($this->app); config(['database.mongodb.default.database' => 'databaseName', 'database.mongodb.default.username' => 'us3r', 'database.mongodb.default.password' => 'p455']); // Actions $provider->registerConnector(); $pool = Ioc::make(Pool::class); // Assertions $this->assertEquals('databaseName', $pool->getConnection()->defaultDatabase); }
public function testShouldGetRawManager() { // Arrange $mongoManager = new Manager('mongodb://localhost:27017'); $container = m::mock(Container::class)->makePartial(); Ioc::setContainer($container); // Act $container->shouldReceive('make')->once()->with(Manager::class, m::any())->andReturn($mongoManager); // Assert $connection = new Connection(); $this->assertEquals($mongoManager, $connection->getRawManager()); }
public function testShouldNotAutoIncrementSequenceIfValueIsNotNull() { $schema = m::mock(Schema::class . '[]'); $sequenceService = m::mock(SequenceService::class); $value = 3; $schema->collection = 'resources'; // Act Ioc::instance(SequenceService::class, $sequenceService); $sequenceService->shouldReceive('getNextValue')->with('resources')->never()->andReturn(7); // Should never be returned // Assertion $this->assertEquals(3, $schema->sequence($value)); }
public function testShouldGetDataMapperForEntitiesWithRegisteredSchemas() { // Arrange $manager = new Manager(); $schema = m::mock(Schema::class); $dataMapper = m::mock(DataMapper::class)->makePartial(); $schema->entityClass = 'Bacon'; // Act Ioc::instance(DataMapper::class, $dataMapper); // Assert $manager->registerSchema($schema); $result = $manager->getMapper('Bacon'); $this->assertEquals($dataMapper, $result); $this->assertAttributeEquals($schema, 'schema', $result); }
/** * Register MongoDbConnector within the application. * * @return void */ public function registerConnector() { $config = $this->app->make('config'); MongolidIoc::setContainer($this->app); $connectionString = $this->buildConnectionString(); $connection = new Connection($connectionString); $pool = new Pool(); $eventService = new EventTriggerService(); $eventService->registerEventDispatcher($this->app->make(LaravelEventTrigger::class)); $pool->addConnection($connection); $this->app->instance(Pool::class, $pool); $this->app->instance(EventTriggerService::class, $eventService); $this->app->bind(CacheComponentInterface::class, function ($app) { return new LaravelCacheComponent($app[CacheRepository::class], $app[Serializer::class]); }); $connection->defaultDatabase = $config->get('database.mongodb.default.database', 'mongolid'); }
/** * @dataProvider EntityAssemblerFixture */ public function testShouldAssembleEntityForTheGivenSchema($inputValue, $availableSchemas, $inputSchema, $expectedOutput) { // Arrange $entityAssembler = new EntityAssembler(); $schemas = []; foreach ($availableSchemas as $key => $value) { $schemas[$key] = m::mock(Schema::class . '[]'); $schemas[$key]->entityClass = $value['entityClass']; $schemas[$key]->fields = $value['fields']; } // Act foreach ($schemas as $className => $instance) { Ioc::instance($className, $instance); } // Assert $result = $entityAssembler->assemble($inputValue, $schemas[$inputSchema]); $this->assertEquals($expectedOutput, $result); }
public function testShouldGetOriginalCursorFromDatabaseAfterTheDocumentLimit() { // Arrange $documentsFromDb = [['name' => 'joe'], ['name' => 'doe']]; $cursor = $this->getCachableCursor()->limit(150); $cacheComponent = m::mock(CacheComponentInterface::class); $rawCollection = m::mock(); $this->setProtected($cursor, 'position', CacheableCursor::DOCUMENT_LIMIT + 1); $this->setProtected($cursor, 'collection', $rawCollection); // Act $cursor->shouldReceive('generateCacheKey')->never(); Ioc::instance(CacheComponentInterface::class, $cacheComponent); $cacheComponent->shouldReceive('get')->with('find:collection:123', null)->never(); $rawCollection->shouldReceive('find')->with([], ['skip' => CacheableCursor::DOCUMENT_LIMIT, 'limit' => 49])->andReturn(new ArrayIterator($documentsFromDb)); $cacheComponent->shouldReceive('put')->never(); // Assert $this->assertEquals(new IteratorIterator(new ArrayIterator($documentsFromDb)), $this->callProtected($cursor, 'getCursor')); }
public function testShouldExecuteBulkWrite() { $entity = m::mock(HasSchemaInterface::class); $schema = m::mock(Schema::class); $entity->schema = $schema; $mongoBulkWrite = m::mock(new MongoBulkWrite()); $pool = m::mock(Pool::class); $connection = m::mock(Connection::class); $manager = m::mock(Manager::class); $connection->defaultDatabase = 'foo'; $schema->collection = 'bar'; $namespace = 'foo.bar'; Ioc::instance(Pool::class, $pool); // Expect $entity->shouldReceive('getSchema')->once()->with()->andReturn($schema); $pool->shouldReceive('getConnection')->once()->with()->andReturn($connection); $connection->shouldReceive('getRawManager')->once()->with()->andReturn($manager); $manager->shouldReceive('executeBulkWrite')->once()->with($namespace, $mongoBulkWrite, m::type(WriteConcern::class))->andReturn(true); $bulkWrite = m::mock(BulkWrite::class . '[getBulkWrite]', [$entity]); $bulkWrite->shouldReceive('getBulkWrite')->once()->with()->andReturn($mongoBulkWrite); // Act $bulkWrite->execute(); }
/** * Unserializes this object. Re-creating the database connection. * * @param mixed $serialized Serialized cursor. * * @return void */ public function unserialize($serialized) { $attributes = unserialize($serialized); $conn = Ioc::make(Pool::class)->getConnection(); $db = $conn->defaultDatabase; $collectionObject = $conn->getRawConnection()->{$db}->{$attributes['collection']}; foreach ($attributes as $key => $value) { $this->{$key} = $value; } $this->collection = $collectionObject; }
public function testShouldSerializeAnActiveCursor() { // Arrange $pool = m::mock(Pool::class); $conn = m::mock(Connection::class); $schema = new DynamicSchema(); $cursor = $this->getCursor($schema, null, 'find', [[]]); $driverCollection = $this->getDriverCollection(); $this->setProtected($cursor, 'collection', $driverCollection); // Act Ioc::instance(Pool::class, $pool); $pool->shouldReceive('getConnection')->andReturn($conn); $conn->shouldReceive('getRawConnection')->andReturn($conn); $conn->defaultDatabase = 'db'; $conn->db = $conn; $conn->my_collection = $driverCollection; // Return the same driver Collection // Assert $result = unserialize(serialize($cursor)); $this->assertEquals($cursor, $result); }
protected function getEventService() { if (!($this->eventService ?? false)) { $this->eventService = m::mock(EventTriggerService::class); Ioc::instance(EventTriggerService::class, $this->eventService); } return $this->eventService; }
/** * Returns the a valid instance from Ioc. * * @throws NoCollectionNameException Throws exception when has no collection filled. * * @return mixed */ private static function getDataMapperInstance() { $instance = Ioc::make(get_called_class()); if (!$instance->getCollectionName()) { throw new NoCollectionNameException(); } return $instance->getDataMapper(); }
public function testShouldGetSchemaIfFieldsIsTheClassName() { // Arrage $this->setProtected($this->entity, 'fields', 'MySchemaClass'); $schema = m::mock(Schema::class); // Act Ioc::instance('MySchemaClass', $schema); // Assert $this->assertEquals($schema, $this->entity->getSchema()); }
/** * Assembly multiple documents for the given $schemaClass recursively. * * @param mixed $value A value of an embeded field containing entity data to be assembled. * @param string $schemaClass The schemaClass to be used when assembling the entities within $value. * * @return mixed */ protected function assembleDocumentsRecursively($value, string $schemaClass) { $value = (array) $value; if (empty($value)) { return; } $schema = Ioc::make($schemaClass); $assembler = Ioc::make(self::class); if (!isset($value[0])) { $value = [$value]; } foreach ($value as $key => $subValue) { $value[$key] = $assembler->assemble($subValue, $schema); } return $value; }
/** * Generates an unique cache key for the cursor in it's current state. * * @return string Cache key to identify the query of the current cursor. */ protected function generateCacheKey() : string { $serializer = Ioc::make(Serializer::class); return sprintf('%s:%s:%s', $this->command, $this->collection->getNamespace(), md5($serializer->serialize($this->params))); }
/** * Removes a document _id reference from an attribute. It will remove the * _id of the given $obj from inside the given $field. * * @param string $field Field where the reference is stored. * @param mixed $obj Document, model instance or _id that have been referenced by $field. * * @return void */ public function detach(string $field, &$obj) { $embedder = Ioc::make(DocumentEmbedder::class); $embedder->detach($this, $field, $obj); }
/** * @dataProvider embedsScenarios */ public function testShouldEmbedsMany($entity, $field, $fieldValue, $expectedItems) { // Set $model = m::mock(ActiveRecord::class . '[]'); $cursorFactory = m::mock(CursorFactory::class); $cursor = m::mock(EmbeddedCursor::class); $document = $fieldValue; $model->{$field} = $document; $instantiableClass = $entity instanceof Schema ? 'stdClass' : get_class($entity); // Act Ioc::instance(CursorFactory::class, $cursorFactory); $cursorFactory->shouldReceive('createEmbeddedCursor')->once()->with($instantiableClass, $expectedItems)->andReturn($cursor); // Assert $result = $this->callProtected($model, 'embedsMany', [get_class($entity), $field]); $this->assertEquals($cursor, $result); }
/** * Constructs a connection pool. */ public function __construct() { $this->connections = Ioc::make('SplQueue'); }
/** * Triggers an event. May return if that event had success. * * @param string $event Identification of the event. * @param mixed $entity Event payload. * @param bool $halt True if the return of the event handler will be used in a conditional. * * @return mixed Event handler return. */ protected function fireEvent(string $event, $entity, bool $halt = false) { $event = "mongolid.{$event}: " . get_class($entity); $this->eventService ? $this->eventService : ($this->eventService = Ioc::make(EventTriggerService::class)); return $this->eventService->fire($event, $entity, $halt); }
public function testShouldMapAnArrayValueToAnotherSchemaSchema() { // Arrange $schema = m::mock(Schema::class); $mySchema = m::mock(Schema::class); $schemaMapper = new SchemaMapper($schema); $value = ['foo' => 'bar']; $test = $this; // Act Ioc::instance('Xd\\MySchema', $mySchema); // Register MySchema in Ioc // When instantiating the SchemaMapper with the specified $param as dependency Ioc::bind(SchemaMapper::class, function ($container, $params) use($value, $mySchema, $test) { // Check if mySchema has been injected correctly $test->assertSame($mySchema, $params[0]); // Instantiate a SchemaMapper with mySchema $anotherSchemaMapper = m::mock(SchemaMapper::class, [$params[0]]); // Set expectation to receiva a map call $anotherSchemaMapper->shouldReceive('map')->once()->with($value)->andReturn(['foo' => 'PARSED']); return $anotherSchemaMapper; }); //Assert $this->assertEquals([['foo' => 'PARSED']], $this->callProtected($schemaMapper, 'mapToSchema', [$value, 'Xd\\MySchema'])); }
/** * Initializes the Mongolid manager. * * @return void */ protected function init() { if ($this->container) { return; } $this->container = new Container(); $this->connectionPool = new Pool(); $this->cacheComponent = new CacheComponent(); $this->container->instance(Pool::class, $this->connectionPool); $this->container->instance(CacheComponentInterface::class, $this->cacheComponent); Ioc::setContainer($this->container); static::$singleton = $this; }
/** * Instantiate another SchemaMapper with the given $schemaClass and maps * the given $value. * * @param mixed $value Value that will be mapped. * @param string $schemaClass Class that will be passed to the new SchemaMapper constructor. * * @return mixed */ protected function mapToSchema($value, string $schemaClass) { $value = (array) $value; $schema = Ioc::make($schemaClass); $mapper = Ioc::make(self::class, [$schema]); if (!isset($value[0])) { $value = [$value]; } foreach ($value as $key => $subValue) { $value[$key] = $mapper->map($subValue); } return $value; }
/** * Execute the BulkWrite, using a connection from the Pool. * The collection is inferred from entity's collection name. * * @param int $writeConcern * * @return \MongoDB\Driver\WriteResult */ public function execute($writeConcern = 1) { $connection = Ioc::make(Pool::class)->getConnection(); $manager = $connection->getRawManager(); $namespace = $connection->defaultDatabase . '.' . $this->schema->collection; return $manager->executeBulkWrite($namespace, $this->getBulkWrite(), new WriteConcern($writeConcern)); }
/** * Iterator interface current. Return a model object * with cursor document. (used in foreach). * * @return mixed */ public function current() { if (!$this->valid()) { return; } $document = $this->items[$this->position]; if ($document instanceof $this->entityClass) { return $document; } $schema = $this->getSchemaForEntity(); $entityAssembler = Ioc::make(EntityAssembler::class, [$schema]); return $entityAssembler->assemble($document, $schema); }
<?php include 'vendor/autoload.php'; if (!extension_loaded('mongodb')) { throw new Exception('MongoClient PHP extension required.', 1); } use Illuminate\Container\Container; use Mongolid\Container\Ioc; Ioc::setContainer(new Container());
/** * Create a new instance of the model. * * @return \MongolidLaravel\MongoLidModel */ protected function createModel() { $class = '\\' . ltrim($this->model, '\\'); return Ioc::make($class); }
/** * {@inheritdoc} */ public function setUp() { parent::setUp(); Ioc::setContainer($this->app); }