func TestKvfileKV(t *testing.T) {
tmpDir, err := ioutil.TempDir("", "camlistore-kvfilekv_test")
if err != nil {
t.Fatal(err)
}
defer os.RemoveAll(tmpDir)
dbname := filepath.Join(tmpDir, "testdb.kvfile")
kv, err := sorted.NewKeyValue(jsonconfig.Obj{
"type": "kv",
"file": dbname,
})
if err != nil {
t.Fatalf("Could not create kvfile sorted kv at %v: %v", dbname, err)
}
kvtest.TestSorted(t, kv)
}
// TestMongoKV tests against a real MongoDB instance, using a Docker container.
func TestMongoKV(t *testing.T) {
// SetupMongoContainer may skip or fatal the test if docker isn't found or something goes wrong when setting up the container.
// Thus, no error is returned
containerID, ip := dockertest.SetupMongoContainer(t)
defer containerID.KillRemove(t)
kv, err := sorted.NewKeyValue(jsonconfig.Obj{
"type": "mongo",
"host": ip,
"database": "camlitest",
})
if err != nil {
t.Fatalf("mongo.NewKeyValue = %v", err)
}
kvtest.TestSorted(t, kv)
}
func TestLeveldbKV(t *testing.T) {
tmpDir, err := ioutil.TempDir("", "camlistore-leveldbkv_test")
if err != nil {
t.Fatal(err)
}
defer os.RemoveAll(tmpDir)
dbname := filepath.Join(tmpDir, "testdb.leveldb")
t.Logf("Testing leveldb %q.", dbname)
kv, err := sorted.NewKeyValue(jsonconfig.Obj{
"type": "leveldb",
"file": dbname,
})
if err != nil {
t.Fatalf("Could not create leveldb sorted kv at %v: %v", dbname, err)
}
kvtest.TestSorted(t, kv)
}
// TestMySQLKV tests against a real MySQL instance, using a Docker container.
func TestMySQLKV(t *testing.T) {
dbname := "camlitest_" + osutil.Username()
containerID, ip := dockertest.SetupMySQLContainer(t, dbname)
defer containerID.KillRemove(t)
kv, err := sorted.NewKeyValue(jsonconfig.Obj{
"type": "mysql",
"host": ip + ":3306",
"database": dbname,
"user": dockertest.MySQLUsername,
"password": dockertest.MySQLPassword,
})
if err != nil {
t.Fatalf("mysql.NewKeyValue = %v", err)
}
kvtest.TestSorted(t, kv)
}
// TestPostgreSQLKV tests against a real PostgreSQL instance, using a Docker container.
func TestPostgreSQLKV(t *testing.T) {
dbname := "camlitest_" + osutil.Username()
containerID, ip := dockertest.SetupPostgreSQLContainer(t, dbname)
defer containerID.KillRemove(t)
kv, err := sorted.NewKeyValue(jsonconfig.Obj{
"type": "postgres",
"host": ip,
"database": dbname,
"user": dockertest.PostgresUsername,
"password": dockertest.PostgresPassword,
"sslmode": "disable",
})
if err != nil {
t.Fatalf("postgres.NewKeyValue = %v", err)
}
kvtest.TestSorted(t, kv)
}
func TestSQLiteKV(t *testing.T) {
if !CompiledIn() {
t.Skip(ErrNotCompiled.Error())
}
tmpDir, err := ioutil.TempDir("", "camlistore-sqlitekv_test")
if err != nil {
t.Fatal(err)
}
defer os.RemoveAll(tmpDir)
dbname := filepath.Join(tmpDir, "testdb.sqlite")
kv, err := sorted.NewKeyValue(jsonconfig.Obj{
"type": "sqlite",
"file": dbname,
})
if err != nil {
t.Fatalf("Could not create sqlite sorted kv at %v: %v", dbname, err)
}
kvtest.TestSorted(t, kv)
}
// TestMySQLKV tests against a real MySQL instance, using a Docker container.
func TestMySQLKV(t *testing.T) {
dbname := "camlitest_" + osutil.Username()
containerID, ip := dockertest.SetupMySQLContainer(t, dbname)
defer containerID.KillRemove(t)
// TODO(mpl): add test for serverVersion once we host the docker image ourselves
// (and hence have the control over the version).
kv, err := sorted.NewKeyValue(jsonconfig.Obj{
"type": "mysql",
"host": ip + ":3306",
"database": dbname,
"user": dockertest.MySQLUsername,
"password": dockertest.MySQLPassword,
})
if err != nil {
t.Fatalf("mysql.NewKeyValue = %v", err)
}
kvtest.TestSorted(t, kv)
}
// TestMongoKV tests against a real MongoDB instance, using a Docker container.
// Currently using https://index.docker.io/u/robinvdvleuten/mongo/
func TestMongoKV(t *testing.T) {
if testing.Short() {
t.Skip("skipping in short mode")
}
if _, err := exec.LookPath("docker"); err != nil {
t.Skip("skipping without docker available in path")
}
if ok, err := dockerHaveImage(mongoImage); !ok || err != nil {
if err != nil {
t.Skipf("Error running docker to check for %s: %v", mongoImage, err)
}
log.Printf("Pulling docker image %s ...", mongoImage)
if err := dockerPull(mongoImage); err != nil {
t.Skipf("Error pulling %s: %v", mongoImage, err)
}
}
containerID, err := dockerRun("-d", mongoImage, "--smallfiles")
if err != nil {
t.Fatalf("docker run: %v", err)
}
defer dockerKillContainer(containerID)
ip, err := dockerIP(containerID)
if err != nil {
t.Fatalf("Error getting container IP: %v", err)
}
if err := netutil.AwaitReachable(ip+":27017", 10*time.Second); err != nil {
t.Fatal("timeout waiting for port to become reachable")
}
kv, err := NewKeyValue(Config{
Server: ip,
Database: "camlitest",
})
if err != nil {
t.Fatalf("monogo.NewKeyValue = %v", err)
}
kvtest.TestSorted(t, kv)
}
func TestSortedKV(t *testing.T) {
kv, clean := newSorted(t)
defer clean()
kvtest.TestSorted(t, kv)
}
func TestSorted_MySQL(t *testing.T) {
kv, clean := newMySQLSorted(t)
defer clean()
kvtest.TestSorted(t, kv)
}
func TestSorted_Kvfile(t *testing.T) {
kv, cleanup := newKvfileSorted(t)
defer cleanup()
kvtest.TestSorted(t, kv)
}
func TestSorted_Postgres(t *testing.T) {
kv, clean := newPostgresSorted(t)
defer clean()
kvtest.TestSorted(t, kv)
}
func TestMemoryKV(t *testing.T) {
kv := sorted.NewMemoryKeyValue()
kvtest.TestSorted(t, kv)
}
func TestSorted_Mongo(t *testing.T) {
kv, cleanup := newMongoSorted(t)
defer cleanup()
kvtest.TestSorted(t, kv)
}
func TestSorted_LevelDB(t *testing.T) {
kv, cleanup := newLevelDBSorted(t)
defer cleanup()
kvtest.TestSorted(t, kv)
}
