Briq
/
jaydebeapi
6
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

Merge pull request #35 from baztian/bugfix/ancient-date 

Don't fail on dates before 1900 on Python < 3
master
baztian 2017-03-21 20:11:00 +01:00 committed by GitHub
parent 0e482a2052 2f0eaeb5e0
commit ef7ad4effa
5 changed files with 96 additions and 52 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

3
README.rst
View File

@ -159,6 +159,9 @@ Changelog
========= =========
- Next version - unreleased - Next version - unreleased
- Don't fail on dates before 1900 on Python < 3.
- 1.1.0 - 2017-03-19 - 1.1.0 - 2017-03-19
- Support BIT and TINYINT type mappings (thanks @Mokubyow for - Support BIT and TINYINT type mappings (thanks @Mokubyow for

8
jaydebeapi/__init__.py
View File

@ -595,8 +595,12 @@ def _to_date(rs, col):
java_val = rs.getDate(col) java_val = rs.getDate(col)
if not java_val: if not java_val:
return return
d = datetime.datetime.strptime(str(java_val)[:10], "%Y-%m-%d") # The following code requires Python 3.3+ on dates before year 1900.
return d.strftime("%Y-%m-%d") # d = datetime.datetime.strptime(str(java_val)[:10], "%Y-%m-%d")
# return d.strftime("%Y-%m-%d")
# Workaround / simpler soltution (see
# https://github.com/baztian/jaydebeapi/issues/18):
return str(java_val)[:10]
def _to_binary(rs, col): def _to_binary(rs, col):
java_val = rs.getObject(col) java_val = rs.getObject(col)

5
mockdriver/pom.xml
View File

@ -7,6 +7,11 @@
<version>1.0-SNAPSHOT</version> <version>1.0-SNAPSHOT</version>
<packaging>jar</packaging> <packaging>jar</packaging>
<properties>
<maven.compiler.source>1.7</maven.compiler.source>
<maven.compiler.target>1.7</maven.compiler.target>
</properties>
<dependencies> <dependencies>
<dependency> <dependency>
<groupId>org.mockito</groupId> <groupId>org.mockito</groupId>

125
mockdriver/src/main/java/org/jaydebeapi/mockdriver/MockConnection.java
View File

@ -2,73 +2,98 @@ package org.jaydebeapi.mockdriver;
import java.lang.reflect.Field; import java.lang.reflect.Field;
import java.sql.Connection; import java.sql.Connection;
import java.sql.Date;
import java.sql.PreparedStatement; import java.sql.PreparedStatement;
import java.sql.ResultSet; import java.sql.ResultSet;
import java.sql.ResultSetMetaData; import java.sql.ResultSetMetaData;
import java.sql.SQLException; import java.sql.SQLException;
import java.sql.Types; import java.sql.Types;
import java.util.Calendar;
import org.mockito.Mockito; import org.mockito.Mockito;
public abstract class MockConnection implements Connection { public abstract class MockConnection implements Connection {
ResultSet mockResultSet; ResultSet mockResultSet;
public final void mockExceptionOnCommit(String className, String exceptionMessage) throws SQLException { private static Throwable createException(String className, String exceptionMessage) {
Throwable exception = createException(className, exceptionMessage); try {
Mockito.doThrow(exception).when(this).commit(); return (Throwable) Class.forName(className).getConstructor(String.class)
.newInstance(exceptionMessage);
} catch (Exception e) {
throw new RuntimeException("Couldn't initialize class " + className + ".", e);
} }
}
public final void mockExceptionOnRollback(String className, String exceptionMessage) throws SQLException { private static int extractTypeCodeForName(String sqlTypesName) {
Throwable exception = createException(className, exceptionMessage); try {
Mockito.doThrow(exception).when(this).rollback(); Field field = Types.class.getField(sqlTypesName);
return field.getInt(null);
} catch (NoSuchFieldException e) {
throw new IllegalArgumentException("Type " + sqlTypesName + " not found in Types class.", e);
} catch (SecurityException e) {
throw new RuntimeException(e);
} catch (IllegalArgumentException e) {
throw new RuntimeException(e);
} catch (IllegalAccessException e) {
throw new RuntimeException(e);
} }
}
public final void mockExceptionOnExecute(String className, String exceptionMessage) throws SQLException { public final void mockExceptionOnCommit(String className, String exceptionMessage)
PreparedStatement mockPreparedStatement = Mockito.mock(PreparedStatement.class); throws SQLException {
Throwable exception = createException(className, exceptionMessage); Throwable exception = createException(className, exceptionMessage);
Mockito.when(mockPreparedStatement.execute()).thenThrow(exception); Mockito.doThrow(exception).when(this).commit();
Mockito.when(this.prepareStatement(Mockito.anyString())).thenReturn(mockPreparedStatement); }
}
public final void mockType(String sqlTypesName) throws SQLException { public final void mockExceptionOnRollback(String className, String exceptionMessage)
PreparedStatement mockPreparedStatement = Mockito.mock(PreparedStatement.class); throws SQLException {
Mockito.when(mockPreparedStatement.execute()).thenReturn(true); Throwable exception = createException(className, exceptionMessage);
mockResultSet = Mockito.mock(ResultSet.class, "ResultSet(for type " + sqlTypesName + ")"); Mockito.doThrow(exception).when(this).rollback();
Mockito.when(mockPreparedStatement.getResultSet()).thenReturn(mockResultSet); }
Mockito.when(mockResultSet.next()).thenReturn(true);
ResultSetMetaData mockMetaData = Mockito.mock(ResultSetMetaData.class);
Mockito.when(mockResultSet.getMetaData()).thenReturn(mockMetaData);
Mockito.when(mockMetaData.getColumnCount()).thenReturn(1);
int sqlTypeCode = extractTypeCodeForName(sqlTypesName);
Mockito.when(mockMetaData.getColumnType(1)).thenReturn(sqlTypeCode);
Mockito.when(this.prepareStatement(Mockito.anyString())).thenReturn(mockPreparedStatement);
}
public final ResultSet verifyResultSet() { public final void mockExceptionOnExecute(String className, String exceptionMessage)
return Mockito.verify(mockResultSet); throws SQLException {
} PreparedStatement mockPreparedStatement = Mockito.mock(PreparedStatement.class);
Throwable exception = createException(className, exceptionMessage);
Mockito.when(mockPreparedStatement.execute()).thenThrow(exception);
Mockito.when(this.prepareStatement(Mockito.anyString())).thenReturn(mockPreparedStatement);
}
private static Throwable createException(String className, String exceptionMessage) { public final void mockDateResult(int year, int month, int day) throws SQLException {
try { PreparedStatement mockPreparedStatement = Mockito.mock(PreparedStatement.class);
return (Throwable) Class.forName(className).getConstructor(String.class).newInstance(exceptionMessage); Mockito.when(mockPreparedStatement.execute()).thenReturn(true);
} catch (Exception e) { mockResultSet = Mockito.mock(ResultSet.class, "ResultSet(for date)");
throw new RuntimeException("Couldn't initialize class " + className + ".", e); Mockito.when(mockPreparedStatement.getResultSet()).thenReturn(mockResultSet);
} Mockito.when(mockResultSet.next()).thenReturn(true);
} ResultSetMetaData mockMetaData = Mockito.mock(ResultSetMetaData.class);
Mockito.when(mockResultSet.getMetaData()).thenReturn(mockMetaData);
Mockito.when(mockMetaData.getColumnCount()).thenReturn(1);
Calendar cal = Calendar.getInstance();
cal.clear();
cal.set(Calendar.YEAR, year);
cal.set(Calendar.MONTH, month - 1);
cal.set(Calendar.DAY_OF_MONTH, day);
Date ancientDate = new Date(cal.getTime().getTime());
Mockito.when(mockResultSet.getDate(1)).thenReturn(ancientDate);
Mockito.when(mockMetaData.getColumnType(1)).thenReturn(Types.DATE);
Mockito.when(this.prepareStatement(Mockito.anyString())).thenReturn(mockPreparedStatement);
}
private static int extractTypeCodeForName(String sqlTypesName) { public final void mockType(String sqlTypesName) throws SQLException {
try { PreparedStatement mockPreparedStatement = Mockito.mock(PreparedStatement.class);
Field field = Types.class.getField(sqlTypesName); Mockito.when(mockPreparedStatement.execute()).thenReturn(true);
return field.getInt(null); mockResultSet = Mockito.mock(ResultSet.class, "ResultSet(for type " + sqlTypesName + ")");
} catch (NoSuchFieldException e) { Mockito.when(mockPreparedStatement.getResultSet()).thenReturn(mockResultSet);
throw new IllegalArgumentException("Type " + sqlTypesName + " not found in Types class.", e); Mockito.when(mockResultSet.next()).thenReturn(true);
} catch (SecurityException e) { ResultSetMetaData mockMetaData = Mockito.mock(ResultSetMetaData.class);
throw new RuntimeException(e); Mockito.when(mockResultSet.getMetaData()).thenReturn(mockMetaData);
} catch (IllegalArgumentException e) { Mockito.when(mockMetaData.getColumnCount()).thenReturn(1);
throw new RuntimeException(e); int sqlTypeCode = extractTypeCodeForName(sqlTypesName);
} catch (IllegalAccessException e) { Mockito.when(mockMetaData.getColumnType(1)).thenReturn(sqlTypeCode);
throw new RuntimeException(e); Mockito.when(this.prepareStatement(Mockito.anyString())).thenReturn(mockPreparedStatement);
} }
}
public final ResultSet verifyResultSet() {
return Mockito.verify(mockResultSet);
}
} }

7
test/test_mock.py
View File

@ -50,6 +50,13 @@ class MockTest(unittest.TestCase):
'getObject')) 'getObject'))
verify_get(1) verify_get(1)
def test_ancient_date_mapped(self):
self.conn.jconn.mockDateResult(1899, 12, 31)
cursor = self.conn.cursor()
cursor.execute("dummy stmt")
result = cursor.fetchone()
self.assertEquals(result[0], "1899-12-31")
def test_sql_exception_on_execute(self): def test_sql_exception_on_execute(self):
self.conn.jconn.mockExceptionOnExecute("java.sql.SQLException", "expected") self.conn.jconn.mockExceptionOnExecute("java.sql.SQLException", "expected")
cursor = self.conn.cursor() cursor = self.conn.cursor()