package swift import ( "fmt" "io" "os" "testing" "time" "github.com/gophercloud/gophercloud" "github.com/gophercloud/gophercloud/openstack/objectstorage/v1/containers" "github.com/gophercloud/gophercloud/openstack/objectstorage/v1/objects" "github.com/gophercloud/gophercloud/pagination" "github.com/hashicorp/terraform/backend" "github.com/hashicorp/terraform/state/remote" "github.com/hashicorp/terraform/terraform" ) // verify that we are doing ACC tests or the Swift tests specifically func testACC(t *testing.T) { skip := os.Getenv("TF_ACC") == "" && os.Getenv("TF_SWIFT_TEST") == "" if skip { t.Log("swift backend tests require setting TF_ACC or TF_SWIFT_TEST") t.Skip() } t.Log("swift backend acceptance tests enabled") } func TestBackend_impl(t *testing.T) { var _ backend.Backend = new(Backend) } func testAccPreCheck(t *testing.T) { v := os.Getenv("OS_AUTH_URL") if v == "" { t.Fatal("OS_AUTH_URL must be set for acceptance tests") } } func TestBackendConfig(t *testing.T) { testACC(t) // Build config config := map[string]interface{}{ "archive_container": "test-tfstate-archive", "container": "test-tfstate", } b := backend.TestBackendConfig(t, New(), backend.TestWrapConfig(config)).(*Backend) if b.container != "test-tfstate" { t.Fatal("Incorrect path was provided.") } if b.archiveContainer != "test-tfstate-archive" { t.Fatal("Incorrect archivepath was provided.") } } func TestBackend(t *testing.T) { testACC(t) container := fmt.Sprintf("terraform-state-swift-test-%x", time.Now().Unix()) b := backend.TestBackendConfig(t, New(), backend.TestWrapConfig(map[string]interface{}{ "container": container, })).(*Backend) defer deleteSwiftContainer(t, b.client, container) backend.TestBackendStates(t, b) } func TestBackendPath(t *testing.T) { testACC(t) path := fmt.Sprintf("terraform-state-swift-test-%x", time.Now().Unix()) t.Logf("[DEBUG] Generating backend config") b := backend.TestBackendConfig(t, New(), backend.TestWrapConfig(map[string]interface{}{ "path": path, })).(*Backend) t.Logf("[DEBUG] Backend configured") defer deleteSwiftContainer(t, b.client, path) t.Logf("[DEBUG] Testing Backend") // Generate some state state1 := terraform.NewState() // state1Lineage := state1.Lineage t.Logf("state1 lineage = %s, serial = %d", state1.Lineage, state1.Serial) // RemoteClient to test with client := &RemoteClient{ client: b.client, archive: b.archive, archiveContainer: b.archiveContainer, container: b.container, } stateMgr := &remote.State{Client: client} stateMgr.WriteState(state1) if err := stateMgr.PersistState(); err != nil { t.Fatal(err) } if err := stateMgr.RefreshState(); err != nil { t.Fatal(err) } // Add some state state1.AddModuleState(&terraform.ModuleState{ Path: []string{"root"}, Outputs: map[string]*terraform.OutputState{ "bar": &terraform.OutputState{ Type: "string", Sensitive: false, Value: "baz", }, }, }) stateMgr.WriteState(state1) if err := stateMgr.PersistState(); err != nil { t.Fatal(err) } } func TestBackendArchive(t *testing.T) { testACC(t) container := fmt.Sprintf("terraform-state-swift-test-%x", time.Now().Unix()) archiveContainer := fmt.Sprintf("%s_archive", container) b := backend.TestBackendConfig(t, New(), backend.TestWrapConfig(map[string]interface{}{ "archive_container": archiveContainer, "container": container, })).(*Backend) defer deleteSwiftContainer(t, b.client, container) defer deleteSwiftContainer(t, b.client, archiveContainer) // Generate some state state1 := terraform.NewState() // state1Lineage := state1.Lineage t.Logf("state1 lineage = %s, serial = %d", state1.Lineage, state1.Serial) // RemoteClient to test with client := &RemoteClient{ client: b.client, archive: b.archive, archiveContainer: b.archiveContainer, container: b.container, } stateMgr := &remote.State{Client: client} stateMgr.WriteState(state1) if err := stateMgr.PersistState(); err != nil { t.Fatal(err) } if err := stateMgr.RefreshState(); err != nil { t.Fatal(err) } // Add some state state1.AddModuleState(&terraform.ModuleState{ Path: []string{"root"}, Outputs: map[string]*terraform.OutputState{ "bar": &terraform.OutputState{ Type: "string", Sensitive: false, Value: "baz", }, }, }) stateMgr.WriteState(state1) if err := stateMgr.PersistState(); err != nil { t.Fatal(err) } archiveObjects := getSwiftObjectNames(t, b.client, archiveContainer) t.Logf("archiveObjects len = %d. Contents = %+v", len(archiveObjects), archiveObjects) if len(archiveObjects) != 1 { t.Fatalf("Invalid number of archive objects. Expected 1, got %d", len(archiveObjects)) } // Download archive state to validate archiveData := downloadSwiftObject(t, b.client, archiveContainer, archiveObjects[0]) t.Logf("Archive data downloaded... Looks like: %+v", archiveData) archiveState, err := terraform.ReadState(archiveData) if err != nil { t.Fatalf("Error Reading State: %s", err) } t.Logf("Archive state lineage = %s, serial = %d, lineage match = %t", archiveState.Lineage, archiveState.Serial, stateMgr.State().SameLineage(archiveState)) if !stateMgr.State().SameLineage(archiveState) { t.Fatal("Got a different lineage") } } // Helper function to download an object in a Swift container func downloadSwiftObject(t *testing.T, osClient *gophercloud.ServiceClient, container, object string) (data io.Reader) { t.Logf("Attempting to download object %s from container %s", object, container) res := objects.Download(osClient, container, object, nil) if res.Err != nil { t.Fatalf("Error downloading object: %s", res.Err) } data = res.Body return } // Helper function to get a list of objects in a Swift container func getSwiftObjectNames(t *testing.T, osClient *gophercloud.ServiceClient, container string) (objectNames []string) { _ = objects.List(osClient, container, nil).EachPage(func(page pagination.Page) (bool, error) { // Get a slice of object names names, err := objects.ExtractNames(page) if err != nil { t.Fatalf("Error extracting object names from page: %s", err) } for _, object := range names { objectNames = append(objectNames, object) } return true, nil }) return } // Helper function to delete Swift container func deleteSwiftContainer(t *testing.T, osClient *gophercloud.ServiceClient, container string) { warning := "WARNING: Failed to delete the test Swift container. It may have been left in your Openstack account and may incur storage charges. (error was %s)" // Remove any objects deleteSwiftObjects(t, osClient, container) // Delete the container deleteResult := containers.Delete(osClient, container) if deleteResult.Err != nil { if _, ok := deleteResult.Err.(gophercloud.ErrDefault404); !ok { t.Fatalf(warning, deleteResult.Err) } } } // Helper function to delete Swift objects within a container func deleteSwiftObjects(t *testing.T, osClient *gophercloud.ServiceClient, container string) { // Get a slice of object names objectNames := getSwiftObjectNames(t, osClient, container) for _, object := range objectNames { result := objects.Delete(osClient, container, object, nil) if result.Err != nil { t.Fatalf("Error deleting object %s from container %s: %s", object, container, result.Err) } } }