Implement tests for AssertionsOnTableExistence

Author: VanRoy

src/main/java/org/assertj/db/api/TableAssert.java

@@ -18,17 +18,17 @@
 
 /**
  * Assertion methods for a {@link Table}.
- * 
+ *
  * @author Régis Pouiller
- * 
+ *
  */
 public class TableAssert
-        extends AbstractDbAssert<Table, TableAssert, TableColumnAssert, TableColumnValueAssert, TableRowAssert, TableRowValueAssert>
-        implements AssertOnExistence<TableAssert> {
+    extends AbstractDbAssert<Table, TableAssert, TableColumnAssert, TableColumnValueAssert, TableRowAssert, TableRowValueAssert>
+    implements AssertOnExistence<TableAssert> {
 
   /**
    * Constructor.
-   * 
+   *
    * @param table Table on which the assertion is.
    */
   TableAssert(Table table) {
@@ -66,6 +66,6 @@ public TableAssert exists() {
    */
   @Override
   public TableAssert doesNotExist() {
-    return null;
+    return AssertionsOnTableExistence.doesNotExists(this, info, actual.getName(), actual.getSource(), actual.getDataSource());
   }
 }

src/main/java/org/assertj/db/api/assertions/AssertOnExistence.java

@@ -1,3 +1,15 @@
+/**
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on
+ * an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations under the License.
+ *
+ * Copyright 2012-2016 the original author or authors.
+ */
 package org.assertj.db.api.assertions;
 
 /**

src/main/java/org/assertj/db/api/assertions/impl/AssertionsOnTableExistence.java

@@ -1,3 +1,15 @@
+/**
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on
+ * an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations under the License.
+ *
+ * Copyright 2012-2016 the original author or authors.
+ */
 package org.assertj.db.api.assertions.impl;
 
 import org.assertj.core.api.WritableAssertionInfo;
@@ -18,21 +30,23 @@
 import static org.assertj.db.error.ShouldNotExist.shouldNotExist;
 
 /**
- * Implements the assertion method on the existence of a table
+ * Implements the assertion method on the existence of a table.
+ *
  * @author Avinash Ananth Narayan
+ *
  */
 public class AssertionsOnTableExistence {
 
   /**
    * To notice failures in the assertion.
    */
-  private final static Failures failures = Failures.instance();
+  private static final Failures failures = Failures.instance();
 
   private AssertionsOnTableExistence() {
     // Empty
   }
 
-  public static <A extends AbstractDbAssert> A exists(A assertion, WritableAssertionInfo info,
+  public static <A extends AbstractDbAssert<?, ?, ?, ?, ?, ?>> A exists(A assertion, WritableAssertionInfo info,
                                                       String table, Source source, DataSource dataSource) {
     try (Connection connection = getConnection(source, dataSource)) {
       DatabaseMetaData metaData = connection.getMetaData();
@@ -47,7 +61,7 @@ public static <A extends AbstractDbAssert> A exists(A assertion, WritableAsserti
     return assertion;
   }
 
-  public static <A extends AbstractDbAssert> A doesNotExists(A assertion, WritableAssertionInfo info,
+  public static <A extends AbstractDbAssert<?, ?, ?, ?, ?, ?>> A doesNotExists(A assertion, WritableAssertionInfo info,
                                                              String table, Source source, DataSource dataSource) {
     try (Connection connection = getConnection(source, dataSource)) {
       DatabaseMetaData metaData = connection.getMetaData();

src/test/java/org/assertj/db/api/assertions/AssertOnExistence_DoesNotExist_Test.java

@@ -0,0 +1,62 @@
+/**
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on
+ * an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations under the License.
+ *
+ * Copyright 2012-2016 the original author or authors.
+ */
+package org.assertj.db.api.assertions;
+
+import org.assertj.core.api.Assertions;
+import org.assertj.db.api.TableAssert;
+import org.assertj.db.common.AbstractTest;
+import org.assertj.db.common.NeedReload;
+import org.assertj.db.type.Table;
+import org.junit.Test;
+
+import static org.assertj.db.api.Assertions.assertThat;
+import static org.junit.Assert.fail;
+
+/**
+ * Tests on {@link AssertOnExistence} class :
+ * {@link AssertOnExistence#doesNotExist()} method.
+ *
+ * @author Julien Roy
+ *
+ */
+public class AssertOnExistence_DoesNotExist_Test extends AbstractTest {
+
+  /**
+   * This method tests the {@code doesNotExist} assertion method.
+   */
+  @Test
+  @NeedReload
+  public void test_table_does_not_exist() {
+    Table table = new Table(source, "not-exist-test");
+    TableAssert tableAssert = assertThat(table);
+    TableAssert tableAssertExistReturn = tableAssert.doesNotExist();
+    Assertions.assertThat(tableAssert).isSameAs(tableAssertExistReturn);
+  }
+
+  /**
+   * This method should fail because the table exist.
+   */
+  @Test
+  @NeedReload
+  public void should_fail_because_table_exist() {
+    Table table = new Table(source, "test");
+
+    try {
+      assertThat(table).doesNotExist();
+      fail("An exception must be raised");
+    } catch (AssertionError e) {
+      Assertions.assertThat(e.getMessage()).isEqualTo(String.format("[TEST table] %n"
+                                                                    + "Expecting not exist but exists"));
+    }
+  }
+}

src/test/java/org/assertj/db/api/assertions/AssertOnExistence_Exists_Test.java

@@ -0,0 +1,62 @@
+/**
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on
+ * an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations under the License.
+ *
+ * Copyright 2012-2016 the original author or authors.
+ */
+package org.assertj.db.api.assertions;
+
+import org.assertj.core.api.Assertions;
+import org.assertj.db.api.TableAssert;
+import org.assertj.db.common.AbstractTest;
+import org.assertj.db.common.NeedReload;
+import org.assertj.db.type.Table;
+import org.junit.Test;
+
+import static org.assertj.db.api.Assertions.assertThat;
+import static org.junit.Assert.fail;
+
+/**
+ * Tests on {@link AssertOnExistence} class :
+ * {@link AssertOnExistence#exists()} method.
+ *
+ * @author Julien Roy
+ *
+ */
+public class AssertOnExistence_Exists_Test extends AbstractTest {
+
+  /**
+   * This method tests the {@code exists} assertion method.
+   */
+  @Test
+  @NeedReload
+  public void test_table_exists() {
+    Table table = new Table(source, "test");
+    TableAssert tableAssert = assertThat(table);
+    TableAssert tableAssertExistReturn = tableAssert.exists();
+    Assertions.assertThat(tableAssert).isSameAs(tableAssertExistReturn);
+  }
+
+  /**
+   * This method should fail because the table not exist.
+   */
+  @Test
+  @NeedReload
+  public void should_fail_because_table_not_exist() {
+    Table table = new Table(source, "not-exist-test");
+
+    try {
+      assertThat(table).exists();
+      fail("An exception must be raised");
+    } catch (AssertionError e) {
+      Assertions.assertThat(e.getMessage()).isEqualTo(String.format("[not-exist-test table] %n"
+                                                                    + "Expecting exist but do not exist"));
+    }
+  }
+}

src/test/java/org/assertj/db/api/assertions/impl/AssertionsOnTableExistence_DoesNotExist_Test.java

@@ -0,0 +1,77 @@
+/**
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on
+ * an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations under the License.
+ *
+ * Copyright 2012-2016 the original author or authors.
+ */
+package org.assertj.db.api.assertions.impl;
+
+import org.assertj.core.api.Assertions;
+import org.assertj.core.api.WritableAssertionInfo;
+import org.assertj.db.api.AbstractDbAssert;
+import org.assertj.db.api.TableAssert;
+import org.assertj.db.common.AbstractTest;
+import org.assertj.db.type.Source;
+import org.assertj.db.type.Table;
+import org.junit.Test;
+
+import javax.sql.DataSource;
+
+import static org.assertj.db.api.Assertions.assertThat;
+import static org.junit.Assert.fail;
+
+/**
+ * Tests on {@link AssertionsOnTableExistence} class :
+ * {@link AssertionsOnTableExistence#doesNotExists(AbstractDbAssert, WritableAssertionInfo, String, Source, DataSource)} method.
+ *
+ * @author Julien Roy
+ *
+ */
+public class AssertionsOnTableExistence_DoesNotExist_Test extends AbstractTest {
+
+  /**
+   * This method tests the {@code doesNotExists} assertion method.
+   */
+  @Test
+  public void test_does_not_exists() {
+    WritableAssertionInfo info = new WritableAssertionInfo();
+    Table table = new Table();
+    TableAssert tableAssert = assertThat(table);
+    TableAssert tableAssert2 = AssertionsOnTableExistence.doesNotExists(tableAssert, info, "not-exist-test", source, null);
+    Assertions.assertThat(tableAssert2).isSameAs(tableAssert);
+    TableAssert tableAssert3 = AssertionsOnTableExistence.doesNotExists(tableAssert, info, "not-exist-test", null, dataSource);
+    Assertions.assertThat(tableAssert3).isSameAs(tableAssert);
+  }
+
+  /**
+   * This method should fail because the table exists.
+   */
+  @Test
+  public void should_fail_because_table_exists() {
+    WritableAssertionInfo info = new WritableAssertionInfo();
+    info.description("description");
+    Table table = new Table();
+    TableAssert tableAssert = assertThat(table);
+    try {
+      AssertionsOnTableExistence.doesNotExists(tableAssert, info, "TEST", source, null);
+      fail("An exception must be raised");
+    } catch (AssertionError e) {
+      Assertions.assertThat(e.getMessage()).isEqualTo(String.format("[description] %n"
+                                                                    + "Expecting not exist but exists"));
+    }
+
+    try {
+      AssertionsOnTableExistence.doesNotExists(tableAssert, info, "TEST", null, dataSource);
+      fail("An exception must be raised");
+    } catch (AssertionError e) {
+      Assertions.assertThat(e.getMessage()).isEqualTo(String.format("[description] %n"
+                                                                    + "Expecting not exist but exists"));
+    }
+  }
+}

src/test/java/org/assertj/db/api/assertions/impl/AssertionsOnTableExistence_Exists_Test.java

@@ -0,0 +1,77 @@
+/**
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on
+ * an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations under the License.
+ *
+ * Copyright 2012-2016 the original author or authors.
+ */
+package org.assertj.db.api.assertions.impl;
+
+import org.assertj.core.api.Assertions;
+import org.assertj.core.api.WritableAssertionInfo;
+import org.assertj.db.api.AbstractDbAssert;
+import org.assertj.db.api.TableAssert;
+import org.assertj.db.common.AbstractTest;
+import org.assertj.db.type.Source;
+import org.assertj.db.type.Table;
+import org.junit.Test;
+
+import javax.sql.DataSource;
+
+import static org.assertj.db.api.Assertions.assertThat;
+import static org.junit.Assert.fail;
+
+/**
+ * Tests on {@link AssertionsOnTableExistence} class :
+ * {@link AssertionsOnTableExistence#exists(AbstractDbAssert, WritableAssertionInfo, String, Source, DataSource)} method.
+ *
+ * @author Julien Roy
+ *
+ */
+public class AssertionsOnTableExistence_Exists_Test extends AbstractTest {
+
+  /**
+   * This method tests the {@code exists} assertion method.
+   */
+  @Test
+  public void test_exists() {
+    WritableAssertionInfo info = new WritableAssertionInfo();
+    Table table = new Table();
+    TableAssert tableAssert = assertThat(table);
+    TableAssert tableAssert2 = AssertionsOnTableExistence.exists(tableAssert, info, "TEST", source, null);
+    Assertions.assertThat(tableAssert2).isSameAs(tableAssert);
+    TableAssert tableAssert3 = AssertionsOnTableExistence.exists(tableAssert, info, "TEST", null, dataSource);
+    Assertions.assertThat(tableAssert3).isSameAs(tableAssert);
+  }
+
+  /**
+   * This method should fail because the table does not exist.
+   */
+  @Test
+  public void should_fail_because_table_does_not_exist() {
+    WritableAssertionInfo info = new WritableAssertionInfo();
+    info.description("description");
+    Table table = new Table();
+    TableAssert tableAssert = assertThat(table);
+    try {
+      AssertionsOnTableExistence.exists(tableAssert, info, "not-exist-test", source, null);
+      fail("An exception must be raised");
+    } catch (AssertionError e) {
+      Assertions.assertThat(e.getMessage()).isEqualTo(String.format("[description] %n"
+                                                                    + "Expecting exist but do not exist"));
+    }
+
+    try {
+      AssertionsOnTableExistence.exists(tableAssert, info, "not-exist-test", null, dataSource);
+      fail("An exception must be raised");
+    } catch (AssertionError e) {
+      Assertions.assertThat(e.getMessage()).isEqualTo(String.format("[description] %n"
+                                                                    + "Expecting exist but do not exist"));
+    }
+  }
+}