Java SQLiteOpenHelper类代码示例

import net.sqlcipher.database.SQLiteOpenHelper; //导入依赖的package包/类
@Test
public void typeMappingShouldWorkWithSpecifiedTypeMappingFinder() {
    TypeMappingFinder typeMappingFinder = new TypeMappingFinderImpl();
    //noinspection unchecked
    SQLiteTypeMapping<ClassEntity> typeMapping = SQLiteTypeMapping.builder()
            .putResolver(mock(PutResolver.class))
            .getResolver(mock(GetResolver.class))
            .deleteResolver(mock(DeleteResolver.class))
            .build();
    CipherStoreIO storIOSQLite = CipherStoreIO.builder()
            .sqliteOpenHelper(mock(SQLiteOpenHelper.class), "password")
            .typeMappingFinder(typeMappingFinder)
            .addTypeMapping(ClassEntity.class, typeMapping)
            .build();
    assertThat(storIOSQLite.lowLevel().typeMapping(ClassEntity.class)).isEqualTo(typeMapping);
}
 

import net.sqlcipher.database.SQLiteOpenHelper; //导入依赖的package包/类
@Test
public void typeMappingShouldWorkForMultipleTypes() {
    class AnotherEntity {
    }
    //noinspection unchecked
    SQLiteTypeMapping<ClassEntity> entityMapping = SQLiteTypeMapping.builder()
            .putResolver(mock(PutResolver.class))
            .getResolver(mock(GetResolver.class))
            .deleteResolver(mock(DeleteResolver.class))
            .build();
    //noinspection unchecked
    SQLiteTypeMapping<AnotherEntity> anotherMapping = SQLiteTypeMapping.builder()
            .putResolver(mock(PutResolver.class))
            .getResolver(mock(GetResolver.class))
            .deleteResolver(mock(DeleteResolver.class))
            .build();
    CipherStoreIO storIOSQLite = CipherStoreIO.builder()
            .sqliteOpenHelper(mock(SQLiteOpenHelper.class), "password")
            .addTypeMapping(ClassEntity.class, entityMapping)
            .addTypeMapping(AnotherEntity.class, anotherMapping)
            .build();
    assertThat(storIOSQLite.lowLevel().typeMapping(ClassEntity.class)).isEqualTo(entityMapping);
    assertThat(storIOSQLite.lowLevel().typeMapping(AnotherEntity.class)).isEqualTo(anotherMapping);
}
 

import net.sqlcipher.database.SQLiteOpenHelper; //导入依赖的package包/类
@Test
public void shouldPassSQLWithArgsToExecSQL() {
    SQLiteOpenHelper sqLiteOpenHelper = mock(SQLiteOpenHelper.class);
    SQLiteDatabase sqLiteDatabase = mock(SQLiteDatabase.class);
    when(sqLiteOpenHelper.getWritableDatabase("password")).thenReturn(sqLiteDatabase);
    StorIOSQLite storIOSQLite = CipherStoreIO.builder()
            .sqliteOpenHelper(sqLiteOpenHelper, "password")
            .build();
    RawQuery rawQuery = RawQuery.builder()
            .query("DROP TABLE users")
            .args("arg1", "arg2")
            .build();
    storIOSQLite
            .lowLevel()
            .executeSQL(rawQuery);
    verify(sqLiteOpenHelper).getWritableDatabase("password");
    verify(sqLiteDatabase).execSQL(eq(rawQuery.query()), eq(new String[]{"arg1", "arg2"}));
    verifyNoMoreInteractions(sqLiteOpenHelper, sqLiteDatabase);
}
 

import net.sqlcipher.database.SQLiteOpenHelper; //导入依赖的package包/类
@Test
public void shouldPassSQLWithoutArgsToExecSQL() {
    SQLiteOpenHelper sqLiteOpenHelper = mock(SQLiteOpenHelper.class);
    SQLiteDatabase sqLiteDatabase = mock(SQLiteDatabase.class);
    when(sqLiteOpenHelper.getWritableDatabase("password")).thenReturn(sqLiteDatabase);
    StorIOSQLite storIOSQLite = CipherStoreIO.builder()
            .sqliteOpenHelper(sqLiteOpenHelper, "password")
            .build();
    RawQuery rawQuery = RawQuery.builder()
            .query("DROP TABLE IF EXISTS someTable")
            .build(); // No args!
    storIOSQLite
            .lowLevel()
            .executeSQL(rawQuery);
    verify(sqLiteOpenHelper).getWritableDatabase("password");
    verify(sqLiteDatabase).execSQL(eq(rawQuery.query()));
    verifyNoMoreInteractions(sqLiteOpenHelper, sqLiteDatabase);
}
 

import net.sqlcipher.database.SQLiteOpenHelper; //导入依赖的package包/类
@Test
public void shouldPassArgsToInsertWithOnConflict() {
    SQLiteOpenHelper sqLiteOpenHelper = mock(SQLiteOpenHelper.class);
    SQLiteDatabase sqLiteDatabase = mock(SQLiteDatabase.class);
    when(sqLiteOpenHelper.getWritableDatabase("password")).thenReturn(sqLiteDatabase);
    StorIOSQLite storIOSQLite = CipherStoreIO.builder()
            .sqliteOpenHelper(sqLiteOpenHelper, "password")
            .build();
    InsertQuery insertQuery = InsertQuery.builder()
            .table("test_table")
            .nullColumnHack("custom_null_hack")
            .build();
    ContentValues contentValues = mock(ContentValues.class);
    int conflictAlgorithm = SQLiteDatabase.CONFLICT_ROLLBACK;
    storIOSQLite.lowLevel().insertWithOnConflict(insertQuery, contentValues, conflictAlgorithm);
    verify(sqLiteDatabase).insertWithOnConflict(
            eq("test_table"),
            eq("custom_null_hack"),
            same(contentValues),
            eq(SQLiteDatabase.CONFLICT_ROLLBACK)
    );
}
 

import net.sqlcipher.database.SQLiteOpenHelper; //导入依赖的package包/类
@Test
public void notifyAboutChangesShouldNotAcceptNullAsChanges() {
    SQLiteOpenHelper sqLiteOpenHelper = mock(SQLiteOpenHelper.class);
    StorIOSQLite storIOSQLite = CipherStoreIO.builder()
            .sqliteOpenHelper(sqLiteOpenHelper, "password")
            .build();
    StorIOSQLite.LowLevel lowLevel = storIOSQLite.lowLevel();
    assertThat(lowLevel).isNotNull();
    try {
        //noinspection ConstantConditions
        lowLevel.notifyAboutChanges(null);
        failBecauseExceptionWasNotThrown(NullPointerException.class);
    } catch (NullPointerException expected) {
        assertThat(expected).hasMessage("Changes can not be null");
    }
}
 

import net.sqlcipher.database.SQLiteOpenHelper; //导入依赖的package包/类
@Test
public void observeChangesAndNotifyAboutChangesShouldWorkCorrectly() {
    SQLiteOpenHelper sqLiteOpenHelper = mock(SQLiteOpenHelper.class);
    StorIOSQLite storIOSQLite = CipherStoreIO.builder()
            .sqliteOpenHelper(sqLiteOpenHelper, "password")
            .build();
    TestSubscriber<Changes> testSubscriber = new TestSubscriber<>();
    storIOSQLite
            .observeChanges()
            .subscribe(testSubscriber);
    testSubscriber.assertNoValues();
    Changes changes = Changes.newInstance("test_table");
    storIOSQLite
            .lowLevel()
            .notifyAboutChanges(changes);
    testSubscriber.assertValue(changes);
    testSubscriber.assertNoErrors();
    testSubscriber.unsubscribe();
}
 

import net.sqlcipher.database.SQLiteOpenHelper; //导入依赖的package包/类
BriteDatabase(Context context,SQLiteOpenHelper helper, @NonNull char[] password, Logger logger, Observable<Set<String>> triggerSource,
    Observer<Set<String>> triggerSink, Scheduler scheduler,
    ObservableTransformer<Query, Query> queryTransformer) {
  SQLiteDatabase.loadLibs(context);
  this.helper = helper;
  this.password = password;
  this.logger = logger;
  this.triggerSource = triggerSource;
  this.triggerSink = triggerSink;
  this.scheduler = scheduler;
  this.queryTransformer = queryTransformer;
}
 

import net.sqlcipher.database.SQLiteOpenHelper; //导入依赖的package包/类
@Provides
@Singleton
BriteDatabase provideDatabase(Application application, SqlBrite sqlBrite, SQLiteOpenHelper helper) {
    BriteDatabase db = sqlBrite.wrapDatabaseHelper(application.getApplicationContext(), helper, PASSWORD, Schedulers.io());
    db.setLoggingEnabled(true);
    return db;
}
 

import net.sqlcipher.database.SQLiteOpenHelper; //导入依赖的package包/类
protected CipherStoreIO(
        @NonNull SQLiteOpenHelper sqLiteOpenHelper,
        @NonNull TypeMappingFinder typeMappingFinder,
        @NonNull String password,
        @Nullable Scheduler defaultScheduler
) {
    this.sqLiteOpenHelper = sqLiteOpenHelper;
    this.defaultScheduler = defaultScheduler;
    this.password = password;
    lowLevel = new LowLevelImpl(typeMappingFinder);
}
 

import net.sqlcipher.database.SQLiteOpenHelper; //导入依赖的package包/类
@Test
public void addTypeMappingNullType() {
    CipherStoreIO.CompleteBuilder builder = CipherStoreIO.builder()
            .sqliteOpenHelper(mock(SQLiteOpenHelper.class), "password");
    expectedException.expect(NullPointerException.class);
    expectedException.expectMessage(equalTo("Please specify type"));
    expectedException.expectCause(nullValue(Throwable.class));
    //noinspection unchecked,ConstantConditions
    builder.addTypeMapping(null, SQLiteTypeMapping.builder()
            .putResolver(mock(PutResolver.class))
            .getResolver(mock(GetResolver.class))
            .deleteResolver(mock(DeleteResolver.class))
            .build());
}
 

import net.sqlcipher.database.SQLiteOpenHelper; //导入依赖的package包/类
@Test
public void addTypeMappingNullMapping() {
    CipherStoreIO.CompleteBuilder builder = CipherStoreIO.builder()
            .sqliteOpenHelper(mock(SQLiteOpenHelper.class), "password");
    expectedException.expect(NullPointerException.class);
    expectedException.expectMessage(equalTo("Please specify type mapping"));
    expectedException.expectCause(nullValue(Throwable.class));
    //noinspection ConstantConditions
    builder.addTypeMapping(Object.class, null);
}
 

import net.sqlcipher.database.SQLiteOpenHelper; //导入依赖的package包/类
@Test
public void nullTypeMappingFinder() {
    CipherStoreIO.CompleteBuilder builder = CipherStoreIO.builder()
            .sqliteOpenHelper(mock(SQLiteOpenHelper.class), "password");
    expectedException.expect(NullPointerException.class);
    expectedException.expectMessage(equalTo("Please specify typeMappingFinder"));
    expectedException.expectCause(nullValue(Throwable.class));
    //noinspection ConstantConditions
    builder.typeMappingFinder(null);
}
 

import net.sqlcipher.database.SQLiteOpenHelper; //导入依赖的package包/类
@Test
public void shouldUseSpecifiedTypeMappingFinder() throws NoSuchFieldException, IllegalAccessException {
    TypeMappingFinder typeMappingFinder = mock(TypeMappingFinder.class);
    CipherStoreIO storIOSQLite = CipherStoreIO.builder()
            .sqliteOpenHelper(mock(SQLiteOpenHelper.class), "password")
            .typeMappingFinder(typeMappingFinder)
            .build();
    assertThat(getTypeMappingFinder(storIOSQLite)).isEqualTo(typeMappingFinder);
}
 

import net.sqlcipher.database.SQLiteOpenHelper; //导入依赖的package包/类
@Test
public void typeMappingShouldWorkWithoutSpecifiedTypeMappingFinder() {
    //noinspection unchecked
    SQLiteTypeMapping<ClassEntity> typeMapping = SQLiteTypeMapping.builder()
            .putResolver(mock(PutResolver.class))
            .getResolver(mock(GetResolver.class))
            .deleteResolver(mock(DeleteResolver.class))
            .build();
    CipherStoreIO storIOSQLite = CipherStoreIO.builder()
            .sqliteOpenHelper(mock(SQLiteOpenHelper.class), "password")
            .addTypeMapping(ClassEntity.class, typeMapping)
            .build();
    assertThat(storIOSQLite.lowLevel().typeMapping(ClassEntity.class)).isEqualTo(typeMapping);
}