Add tests on Schema

phpstan.neon

@@ -16,3 +16,9 @@ parameters:
         -
             message: "#Call to an undefined method PHPUnit\\\\Extension\\\\FunctionMocker::expects\\(\\)\\.#"
             path: tests/*
+        -
+            message: "#Access to an undefined property Mockery\\\\LegacyMockInterface::\\$[a-zA-Z0-9_]+\\.#"
+            path: tests/*
+        -
+            message: "#Call to an undefined method Mockery\\\\Mock::[a-zA-Z0-9_]+\\(\\)\\.#"
+            path: tests/*

tests/SchemaTest.php

@@ -0,0 +1,637 @@
+<?php
+declare(strict_types=1);
+use \Mockery\Adapter\Phpunit\MockeryTestCase;
+use EesyLDAP\Entry;
+use EesyLDAP\LdapException;
+use EesyLDAP\Schema;
+use EesyLDAP\InvalidPropertyException;
+
+
+/**
+ * @covers EesyLDAP\Schema::load
+ * @covers EesyLDAP\Schema::__construct
+ * @runTestsInSeparateProcesses
+ * @preserveGlobalState disabled
+ */
+final class SchemaTest extends MockeryTestCase {
+
+  public function testLoad() {
+    $entry = Mockery::mock('overload:EesyLDAP\Entry');
+    $entry->shouldReceive('get_raw_values')
+          ->andReturn(array());
+    $ldap = Mockery::mock('overload:EesyLDAP\Ldap');
+    $ldap->shouldReceive('get_entry')
+         ->once()
+         ->with(
+           'cn=SubSchema', '(objectclass=*)',
+           ['attributeTypes', 'matchingRules', 'matchingRuleUse', 'objectClasses', 'ldapSyntaxes']
+	       )
+         ->andReturn($entry);
+    $obj = Schema::load($ldap);
+    $this -> assertInstanceOf(Schema::class, $obj);
+  }
+
+  /**
+   * @covers EesyLDAP\Schema::load
+   * @runTestsInSeparateProcesses
+   * @preserveGlobalState disabled
+   */
+  public function testLoadFail() {
+    $raise = true;
+    $ldap = Mockery::mock('overload:EesyLDAP\Ldap');
+    $ldap->shouldReceive('get_entry')
+         ->once()
+         ->with(
+           'cn=SubSchema', '(objectclass=*)',
+           ['attributeTypes', 'matchingRules', 'matchingRuleUse', 'objectClasses', 'ldapSyntaxes']
+	       )
+         ->andReturn(false);
+    $ldap->shouldReceive('error')
+         ->once()
+         ->with('Fail to load cn=SubSchema entry', $raise)
+         ->andThrow(LdapException::class);
+    $this->expectException(LdapException::class);
+    $obj = Schema::load($ldap, $raise);
+  }
+
+  /**
+   * @covers EesyLDAP\Schema::__get
+   */
+  public function testGetLoaded() {
+    $schema = $this -> getSchema();
+    $this -> assertTrue($schema->__get('loaded'));
+  }
+
+  /**
+   * @covers EesyLDAP\Schema::__get
+   */
+  public function testGetInvalidProperty() {
+    $schema = $this -> getSchema();
+    $this->expectException(InvalidPropertyException::class);
+    $this -> assertTrue($schema->__get('undefined'));
+  }
+
+  /**
+   * @return Schema
+   */
+  public function getSchema() {
+    $ldap = Mockery::mock('EesyLDAP\Ldap');
+    $entry = Mockery::mock('EesyLDAP\Entry');
+    $entry->shouldReceive('get_raw_values')
+          ->andReturn(array());
+    return new Schema($ldap, $entry);
+  }
+
+  /**
+   * @covers \EesyLDAP\Schema::parse
+   * @runTestsInSeparateProcesses
+   * @preserveGlobalState disabled
+   */
+  public function testParse() {
+    $data = array(
+      'attributeTypes'   => array(
+        "type" => "Attribute",
+        "values" => array(
+          "( 2.5.4.0 NAME 'objectClass' DESC 'RFC4512: object classes of the entity' EQUALITY ".
+          "objectIdentifierMatch SYNTAX 1.3.6.1.4.1.1466.115.121.1.38 )",
+        ),
+        "oid" => "2.5.4.0",
+        "name" => "objectClass",
+        "entry" => null,
+      ),
+      'matchingRules'    => array(
+        "type" => "MatchingRule",
+        "values" => array(
+          "( 2.5.13.20 NAME 'telephoneNumberMatch' SYNTAX 1.3.6.1.4.1.1466.115.121.1.50 )",
+        ),
+        "oid" => "2.5.13.20",
+        "name" => "telephoneNumberMatch",
+        "entry" => null,
+      ),
+      'matchingRuleUse'  => array(
+        "type" => "MatchingRuleUse",
+        "values" => array(
+          "( 2.5.13.20 NAME 'telephoneNumberMatch' APPLIES ( telephoneNumber $ homePhone $ mobile".
+          " $ pager ) )",
+        ),
+        "oid" => "2.5.13.20",
+        "name" => "telephoneNumberMatch",
+        "entry" => null,
+      ),
+      'objectClasses'    => array(
+        "type" => "ObjectClass",
+        "values" => array(
+          "( 2.5.6.14 NAME 'device' DESC 'RFC2256: a device' SUP top STRUCTURAL MUST cn MAY ( ".
+          "serialNumber $ seeAlso $ owner $ ou $ o $ l $ description ) )",
+        ),
+        "oid" => "2.5.6.14",
+        "name" => "device",
+        "entry" => null,
+      ),
+      'ldapSyntaxes'     => array(
+        "type" => "Syntax",
+        "values" => array(
+          "( 1.3.6.1.4.1.1466.115.121.1.7 DESC 'Boolean' )",
+        ),
+        "oid" => "1.3.6.1.4.1.1466.115.121.1.7",
+        "name" => "Boolean",
+        "entry" => null,
+      ),
+    );
+    $entry = Mockery::mock('EesyLDAP\Entry');
+    foreach($data as $attr => $info) {
+      $entry->shouldReceive('get_raw_values')
+            ->once()
+            ->with($attr, array(), true)
+            ->andReturn($info['values']);
+      $data[$attr]['entry'] = Mockery::mock('EesyLDAP\Schema\SchemaEntry');
+      // @phpstan-ignore-next-line
+      $data[$attr]['entry']->oid = $info['oid'];
+      // @phpstan-ignore-next-line
+      $data[$attr]['entry']->name = $info['name'];
+      $data[$attr]['mock'] = Mockery::mock("overload:EesyLDAP\\Schema\\".$info['type']);
+      // @phpstan-ignore-next-line
+      $data[$attr]['mock']->shouldReceive('parse')
+                          ->once()
+                          ->with($info['values'][0])
+                          ->andReturn($data[$attr]['entry']);
+    }
+
+    $schema = Mockery::mock('EesyLDAP\Schema')
+        ->shouldAllowMockingProtectedMethods();
+    $reflection = new ReflectionClass($schema);
+    $entry_property = $reflection->getProperty('entry');
+    $entry_property->setAccessible(true);
+    $entry_property->setValue($schema, $entry);
+
+    $schema->shouldReceive('parse')->passthru();
+
+    $parse_method = new ReflectionMethod('EesyLDAP\Schema', 'parse');
+    $parse_method->setAccessible(true);
+    $parse_method->invoke($schema);
+
+    $reflection = new ReflectionClass($schema);
+    $entries_property = $reflection->getProperty('entries');
+    $entries_property->setAccessible(true);
+    $entries = $entries_property->getValue($schema);
+    $oids_property = $reflection->getProperty('oids');
+    $oids_property->setAccessible(true);
+    $oids = $oids_property->getValue($schema);
+
+    foreach($data as $attr => $info) {
+      // @phpstan-ignore-next-line
+      $this->assertSame($info['entry'], $entries[strtolower($info['type'])][$info['name']]);
+      // @phpstan-ignore-next-line
+      $this->assertEquals($info['entry'], $oids[$info['oid']]);
+    }
+  }
+
+  /**
+   * @covers \EesyLDAP\Schema::parse
+   * @runTestsInSeparateProcesses
+   * @preserveGlobalState disabled
+   */
+  public function testParseBadSchemaValue() {
+    $attr = "attributeTypes";
+    $value = "bad value";
+    $ldap = Mockery::mock('EesyLDAP\Ldap');
+    $ldap->shouldReceive('error')
+      ->once()
+      ->with("Fail to parse %s schema value: %s", null, $attr, $value)
+      ->andThrow(LdapException::class);
+
+    $entry = Mockery::mock('EesyLDAP\Entry');
+    $entry->shouldReceive('get_raw_values')
+      ->once()
+      ->with($attr, array(), true)
+      ->andReturn(array($value));
+
+    $attribute = Mockery::mock("overload:EesyLDAP\Schema\Attribute");
+    $attribute->shouldReceive('parse')
+      ->once()
+      ->with($value)
+      ->andReturn(false);
+
+    $schema = Mockery::mock('EesyLDAP\Schema')
+        ->shouldAllowMockingProtectedMethods();
+    $reflection = new ReflectionClass($schema);
+    $ldap_property = $reflection->getProperty('ldap');
+    $ldap_property->setAccessible(true);
+    $ldap_property->setValue($schema, $ldap);
+    $entry_property = $reflection->getProperty('entry');
+    $entry_property->setAccessible(true);
+    $entry_property->setValue($schema, $entry);
+
+    $schema->shouldReceive('parse')->passthru();
+
+    $this->expectException(LdapException::class);
+
+    $parse_method = new ReflectionMethod('EesyLDAP\Schema', 'parse');
+    $parse_method->setAccessible(true);
+    $parse_method->invoke($schema);
+  }
+
+  /**
+   * @covers \EesyLDAP\Schema::parse
+   * @runTestsInSeparateProcesses
+   * @preserveGlobalState disabled
+   */
+  public function testParseDuplicateOid() {
+    $attr = "attributeTypes";
+    $oid = "1.2.3";
+    $value1 = "test1";
+    $entry1 = Mockery::mock('EesyLDAP\Schema\SchemaEntry');
+    $entry1->oid = $oid;
+    $entry1->name = "test1";
+    $value2 = "test2";
+    $entry2 = Mockery::mock('EesyLDAP\Schema\SchemaEntry');
+    $entry2->oid = $oid;
+    $entry2->name = "test2";
+
+    $ldap = Mockery::mock('EesyLDAP\Ldap');
+    $ldap->shouldReceive('error')
+      ->once()
+      ->with("Duplicate OID %s found in schema: %s / %s", null, $oid, $entry1, $entry2)
+      ->andThrow(LdapException::class);
+
+    $entry = Mockery::mock('EesyLDAP\Entry');
+    $entry->shouldReceive('get_raw_values')
+      ->once()
+      ->with($attr, array(), true)
+      ->andReturn(array($value1, $value2));
+
+    $attribute = Mockery::mock("overload:EesyLDAP\Schema\Attribute");
+    $attribute->shouldReceive('parse')
+      ->once()
+      ->with($value1)
+      ->andReturn($entry1)
+      ->shouldReceive('parse')
+      ->once()
+      ->with($value2)
+      ->andReturn($entry2);
+
+    $schema = Mockery::mock('EesyLDAP\Schema')
+        ->shouldAllowMockingProtectedMethods();
+    $reflection = new ReflectionClass($schema);
+    $ldap_property = $reflection->getProperty('ldap');
+    $ldap_property->setAccessible(true);
+    $ldap_property->setValue($schema, $ldap);
+    $entry_property = $reflection->getProperty('entry');
+    $entry_property->setAccessible(true);
+    $entry_property->setValue($schema, $entry);
+
+    $schema->shouldReceive('parse')->passthru();
+
+    $this->expectException(LdapException::class);
+
+    $parse_method = new ReflectionMethod('EesyLDAP\Schema', 'parse');
+    $parse_method->setAccessible(true);
+    $parse_method->invoke($schema);
+  }
+
+  /**
+   * @covers \EesyLDAP\Schema::parse
+   * @runTestsInSeparateProcesses
+   * @preserveGlobalState disabled
+   */
+  public function testParseDuplicateName() {
+    $attr = "attributeTypes";
+    $name = "test";
+    $value1 = "test1";
+    $entry1 = Mockery::mock('EesyLDAP\Schema\SchemaEntry');
+    $entry1->oid = "1.2.3";
+    $entry1->name = $name;
+    $value2 = "test2";
+    $entry2 = Mockery::mock('EesyLDAP\Schema\SchemaEntry');
+    $entry2->oid = "1.2.4";
+    $entry2->name = $name;
+
+    $ldap = Mockery::mock('EesyLDAP\Ldap');
+    $ldap->shouldReceive('error')
+      ->once()
+      ->with(
+        "Duplicate %s schema entry %s found: %s / %s",
+        null, "Attribute", $name, $entry1, $entry2)
+      ->andThrow(LdapException::class);
+
+    $entry = Mockery::mock('EesyLDAP\Entry');
+    $entry->shouldReceive('get_raw_values')
+      ->once()
+      ->with($attr, array(), true)
+      ->andReturn(array($value1, $value2));
+
+    $attribute = Mockery::mock("overload:EesyLDAP\Schema\Attribute");
+    $attribute->shouldReceive('parse')
+      ->once()
+      ->with($value1)
+      ->andReturn($entry1)
+      ->shouldReceive('parse')
+      ->once()
+      ->with($value2)
+      ->andReturn($entry2);
+
+    $schema = Mockery::mock('EesyLDAP\Schema')
+        ->shouldAllowMockingProtectedMethods();
+    $reflection = new ReflectionClass($schema);
+    $ldap_property = $reflection->getProperty('ldap');
+    $ldap_property->setAccessible(true);
+    $ldap_property->setValue($schema, $ldap);
+    $entry_property = $reflection->getProperty('entry');
+    $entry_property->setAccessible(true);
+    $entry_property->setValue($schema, $entry);
+
+    $schema->shouldReceive('parse')->passthru();
+
+    $this->expectException(LdapException::class);
+
+    $parse_method = new ReflectionMethod('EesyLDAP\Schema', 'parse');
+    $parse_method->setAccessible(true);
+    $parse_method->invoke($schema);
+  }
+
+  /**
+   * @covers \EesyLDAP\Schema::_get_entry
+   */
+  public function testGetEntryByOid() {
+    $schema = Mockery::mock('EesyLDAP\Schema')
+        ->shouldAllowMockingProtectedMethods();
+    $reflection = new ReflectionClass($schema);
+    $schema->shouldReceive('_get_entry')->passthru();
+
+    $oid = "1.2.3";
+    $attr = Mockery::mock('EesyLDAP\Schema\Attribute');
+
+    $reflection = new ReflectionClass($schema);
+    $oids_property = $reflection->getProperty('oids');
+    $oids_property->setAccessible(true);
+    $oids_property->setValue($schema, array($oid => $attr));
+
+    $get_entry_method = new ReflectionMethod('EesyLDAP\Schema', '_get_entry');
+    $get_entry_method->setAccessible(true);
+    $this->assertSame($attr, $get_entry_method->invoke($schema, "Attribute", $oid));
+  }
+
+  /**
+   * @covers \EesyLDAP\Schema::_get_entry
+   */
+  public function testGetEntryByName() {
+    $schema = Mockery::mock('EesyLDAP\Schema')
+        ->shouldAllowMockingProtectedMethods();
+    $reflection = new ReflectionClass($schema);
+    $schema->shouldReceive('_get_entry')->passthru();
+
+    $name = "test";
+    $attr = Mockery::mock('EesyLDAP\Schema\Attribute');
+    $attr->shouldReceive('is_me')
+      ->once()
+      ->with($name)
+      ->andReturn(true);
+
+    $reflection = new ReflectionClass($schema);
+    $entries_property = $reflection->getProperty('entries');
+    $entries_property->setAccessible(true);
+    $entries_property->setValue($schema, array("attribute" => array($name => $attr)));
+
+    $get_entry_method = new ReflectionMethod('EesyLDAP\Schema', '_get_entry');
+    $get_entry_method->setAccessible(true);
+    $this->assertSame($attr, $get_entry_method->invoke($schema, "Attribute", $name));
+  }
+
+  /**
+   * @covers \EesyLDAP\Schema::_get_entry
+   */
+  public function testGetEntryUndefinedType() {
+    $schema = Mockery::mock('EesyLDAP\Schema')
+        ->shouldAllowMockingProtectedMethods();
+    $reflection = new ReflectionClass($schema);
+    $schema->shouldReceive('_get_entry')->passthru();
+
+    $reflection = new ReflectionClass($schema);
+    $get_entry_method = new ReflectionMethod('EesyLDAP\Schema', '_get_entry');
+    $get_entry_method->setAccessible(true);
+    $this->assertFalse($get_entry_method->invoke($schema, "Attribute", "undefined"));
+  }
+
+  /**
+   * @covers \EesyLDAP\Schema::_get_entry
+   */
+  public function testGetEntryUndefinedEntry() {
+    $schema = Mockery::mock('EesyLDAP\Schema')
+        ->shouldAllowMockingProtectedMethods();
+    $reflection = new ReflectionClass($schema);
+    $schema->shouldReceive('_get_entry')->passthru();
+
+    $reflection = new ReflectionClass($schema);
+    $entries_property = $reflection->getProperty('entries');
+    $entries_property->setAccessible(true);
+    $entries_property->setValue($schema, array("attribute" => array()));
+    $get_entry_method = new ReflectionMethod('EesyLDAP\Schema', '_get_entry');
+    $get_entry_method->setAccessible(true);
+    $this->assertFalse($get_entry_method->invoke($schema, "Attribute", "undefined"));
+  }
+
+  /**
+   * @covers \EesyLDAP\Schema::attribute
+   */
+  public function testAttribute() {
+    $name = 'test';
+    $entry = Mockery::mock("overload:EesyLDAP\Schema\Attribute");
+    $schema = Mockery::mock('EesyLDAP\Schema')
+        ->shouldAllowMockingProtectedMethods();
+    $schema->shouldReceive('_get_entry')
+      ->once()
+      ->with("Attribute", $name)
+      ->andReturn($entry);
+    $schema->shouldReceive('attribute')->passthru();
+    $this->assertSame($entry, $schema->attribute($name));
+  }
+
+  /**
+   * @covers \EesyLDAP\Schema::objectclass
+   */
+  public function testObjectclass() {
+    $name = 'test';
+    $entry = Mockery::mock("overload:EesyLDAP\Schema\ObjectClass");
+    $schema = Mockery::mock('EesyLDAP\Schema')
+        ->shouldAllowMockingProtectedMethods();
+    $schema->shouldReceive('_get_entry')
+      ->once()
+      ->with("ObjectClass", $name)
+      ->andReturn($entry);
+    $schema->shouldReceive('objectclass')->passthru();
+    $this->assertSame($entry, $schema->objectclass($name));
+  }
+
+  /**
+   * @covers \EesyLDAP\Schema::matching_rule
+   */
+  public function testMatchingRule() {
+    $name = 'test';
+    $entry = Mockery::mock("overload:EesyLDAP\Schema\MatchingRule");
+    $schema = Mockery::mock('EesyLDAP\Schema')
+        ->shouldAllowMockingProtectedMethods();
+    $schema->shouldReceive('_get_entry')
+      ->once()
+      ->with("MatchingRule", $name)
+      ->andReturn($entry);
+    $schema->shouldReceive('matching_rule')->passthru();
+    $this->assertSame($entry, $schema->matching_rule($name));
+  }
+
+  /**
+   * @covers \EesyLDAP\Schema::matching_rule_use
+   */
+  public function testMatchingRuleUse() {
+    $name = 'test';
+    $entry = Mockery::mock("overload:EesyLDAP\Schema\MatchingRuleUse");
+    $schema = Mockery::mock('EesyLDAP\Schema')
+        ->shouldAllowMockingProtectedMethods();
+    $schema->shouldReceive('_get_entry')
+      ->once()
+      ->with("MatchingRuleUse", $name)
+      ->andReturn($entry);
+    $schema->shouldReceive('matching_rule_use')->passthru();
+    $this->assertSame($entry, $schema->matching_rule_use($name));
+  }
+
+  /**
+   * @covers \EesyLDAP\Schema::syntax
+   */
+  public function testSyntax() {
+    $name = 'test';
+    $entry = Mockery::mock("overload:EesyLDAP\Schema\Syntax");
+    $schema = Mockery::mock('EesyLDAP\Schema')
+        ->shouldAllowMockingProtectedMethods();
+    $schema->shouldReceive('_get_entry')
+      ->once()
+      ->with("Syntax", $name)
+      ->andReturn($entry);
+    $schema->shouldReceive('syntax')->passthru();
+    $this->assertSame($entry, $schema->syntax($name));
+  }
+
+  /**
+   * @covers \EesyLDAP\Schema::has_attribute
+   */
+  public function testHasAttribute() {
+    $attr = 'test';
+    $oc1 = Mockery::mock("overload:EesyLDAP\Schema\ObjectClass");
+    $oc1_name = 'test1';
+    $oc1->shouldReceive('has_attribute')
+      ->once()
+      ->with($attr)
+      ->andReturn(false);
+    $oc2 = Mockery::mock("overload:EesyLDAP\Schema\ObjectClass");
+    $oc2_name = 'test2';
+    $oc2->shouldReceive('has_attribute')
+      ->once()
+      ->with($attr)
+      ->andReturn(true);
+    $schema = Mockery::mock('EesyLDAP\Schema')
+        ->shouldAllowMockingProtectedMethods();
+    $schema->shouldReceive('objectclass')
+      ->once()
+      ->with($oc1_name)
+      ->andReturn($oc1)
+      ->shouldReceive('objectclass')
+      ->once()
+      ->with($oc2_name)
+      ->andReturn($oc2);
+    $schema->shouldReceive('has_attribute')->passthru();
+    $this->assertTrue($schema->has_attribute($attr, $oc1_name, $oc2_name));
+  }
+
+  /**
+   * @covers \EesyLDAP\Schema::has_attribute
+   */
+  public function testHasAttributeWithArray() {
+    $attr = 'test';
+    $oc1 = Mockery::mock("overload:EesyLDAP\Schema\ObjectClass");
+    $oc1_name = 'test1';
+    $oc1->shouldReceive('has_attribute')
+      ->once()
+      ->with($attr)
+      ->andReturn(false);
+    $oc2 = Mockery::mock("overload:EesyLDAP\Schema\ObjectClass");
+    $oc2_name = 'test2';
+    $oc2->shouldReceive('has_attribute')
+      ->once()
+      ->with($attr)
+      ->andReturn(true);
+    $schema = Mockery::mock('EesyLDAP\Schema')
+        ->shouldAllowMockingProtectedMethods();
+    $schema->shouldReceive('objectclass')
+      ->once()
+      ->with($oc1_name)
+      ->andReturn($oc1)
+      ->shouldReceive('objectclass')
+      ->once()
+      ->with($oc2_name)
+      ->andReturn($oc2);
+    $schema->shouldReceive('has_attribute')->passthru();
+    $this->assertTrue($schema->has_attribute($attr, [$oc1_name, $oc2_name]));
+  }
+
+  /**
+   * @covers \EesyLDAP\Schema::has_attribute
+   */
+  public function testHasAttributeWithArrayAndContinue() {
+    $attr = 'test';
+    $oc1 = Mockery::mock("overload:EesyLDAP\Schema\ObjectClass");
+    $oc1_name = 'test1';
+    $oc1->shouldReceive('has_attribute')
+      ->once()
+      ->with($attr)
+      ->andReturn(false);
+    $oc2 = Mockery::mock("overload:EesyLDAP\Schema\ObjectClass");
+    $oc2_name = 'test2';
+    $oc2->shouldReceive('has_attribute')
+      ->once()
+      ->with($attr)
+      ->andReturn(true);
+    $schema = Mockery::mock('EesyLDAP\Schema')
+        ->shouldAllowMockingProtectedMethods();
+    $schema->shouldReceive('objectclass')
+      ->once()
+      ->with($oc1_name)
+      ->andReturn($oc1)
+      ->shouldReceive('objectclass')
+      ->once()
+      ->with($oc2_name)
+      ->andReturn($oc2);
+    $schema->shouldReceive('has_attribute')->passthru();
+    $this->assertTrue($schema->has_attribute($attr, [$oc1_name], $oc2_name));
+  }
+
+  /**
+   * @covers \EesyLDAP\Schema::has_attribute
+   */
+  public function testHasAttributeBadObjectClass() {
+    $attr = 'test';
+    $bad_oc_name = 'badOc';
+    $schema = Mockery::mock('EesyLDAP\Schema')
+        ->shouldAllowMockingProtectedMethods();
+    $schema->shouldReceive('objectclass')
+      ->once()
+      ->with($bad_oc_name)
+      ->andReturn(false);
+    $schema->shouldReceive('has_attribute')->passthru();
+    $this->assertFalse($schema->has_attribute($attr, $bad_oc_name));
+  }
+
+  /**
+   * @covers \EesyLDAP\Schema::has_attribute
+   */
+  public function testHasNotAttribute() {
+    $bad_oc_name = "badOc";
+    $schema = Mockery::mock('EesyLDAP\Schema')
+        ->shouldAllowMockingProtectedMethods();
+    $schema->shouldReceive('objectclass')
+      ->once()
+      ->with($bad_oc_name)
+      ->andReturn(false);
+    $schema->shouldReceive('has_attribute')->passthru();
+    $this->assertFalse($schema->has_attribute("test", $bad_oc_name));
+  }
+
+}