Implement archive provider and "archive_file" resource.

builtin/bins/provider-zip/main.go → builtin/bins/provider-archive/main.go

@@ -1,12 +1,12 @@
 package main
 
 import (
-	"github.com/hashicorp/terraform/builtin/providers/zip"
+	"github.com/hashicorp/terraform/builtin/providers/archive"
 	"github.com/hashicorp/terraform/plugin"
 )
 
 func main() {
 	plugin.Serve(&plugin.ServeOpts{
-		ProviderFunc: zip.Provider,
+		ProviderFunc: archive.Provider,
 	})
 }

builtin/providers/zip/archiver.go → builtin/providers/archive/archiver.go

@@ -1,4 +1,4 @@
-package zip
+package archive
 
 import (
 	"fmt"

builtin/providers/zip/provider.go → builtin/providers/archive/provider.go

@@ -1,4 +1,4 @@
-package zip
+package archive
 
 import (
 	"github.com/hashicorp/terraform/helper/schema"
@@ -10,7 +10,7 @@ func Provider() terraform.ResourceProvider {
 		Schema: map[string]*schema.Schema{},
 
 		ResourcesMap: map[string]*schema.Resource{
-			"zip_file": resourceZipFile(),
+			"archive_file": resourceArchiveFile(),
 		},
 	}
 }

builtin/providers/zip/provider_test.go → builtin/providers/archive/provider_test.go

@@ -1,4 +1,4 @@
-package zip
+package archive
 
 import (
 	"testing"
@@ -8,7 +8,7 @@ import (
 )
 
 var testProviders = map[string]terraform.ResourceProvider{
-	"zip": Provider(),
+	"archive": Provider(),
 }
 
 func TestProvider(t *testing.T) {

builtin/providers/zip/resource_zip_file.go → builtin/providers/archive/resource_archive_file.go

@@ -1,4 +1,4 @@
-package zip
+package archive
 
 import (
 	"crypto/sha1"
@@ -9,13 +9,13 @@ import (
 	"os"
 )
 
-func resourceZipFile() *schema.Resource {
+func resourceArchiveFile() *schema.Resource {
 	return &schema.Resource{
-		Create: resourceZipFileCreate,
-		Read:   resourceZipFileRead,
-		Update: resourceZipFileUpdate,
-		Delete: resourceZipFileDelete,
-		Exists: resourceZipFileExists,
+		Create: resourceArchiveFileCreate,
+		Read:   resourceArchiveFileRead,
+		Update: resourceArchiveFileUpdate,
+		Delete: resourceArchiveFileDelete,
+		Exists: resourceArchiveFileExists,
 
 		Schema: map[string]*schema.Schema{
 			"type": &schema.Schema{
@@ -66,14 +66,14 @@ func resourceZipFile() *schema.Resource {
 	}
 }
 
-func resourceZipFileCreate(d *schema.ResourceData, meta interface{}) error {
-	if err := resourceZipFileUpdate(d, meta); err != nil {
+func resourceArchiveFileCreate(d *schema.ResourceData, meta interface{}) error {
+	if err := resourceArchiveFileUpdate(d, meta); err != nil {
 		return err
 	}
-	return resourceZipFileRead(d, meta)
+	return resourceArchiveFileRead(d, meta)
 }
 
-func resourceZipFileRead(d *schema.ResourceData, meta interface{}) error {
+func resourceArchiveFileRead(d *schema.ResourceData, meta interface{}) error {
 	output_path := d.Get("output_path").(string)
 	fi, err := os.Stat(output_path)
 	if os.IsNotExist(err) {
@@ -93,7 +93,7 @@ func resourceZipFileRead(d *schema.ResourceData, meta interface{}) error {
 	return nil
 }
 
-func resourceZipFileUpdate(d *schema.ResourceData, meta interface{}) error {
+func resourceArchiveFileUpdate(d *schema.ResourceData, meta interface{}) error {
 	archiveType := d.Get("type").(string)
 	outputPath := d.Get("output_path").(string)
 
@@ -137,7 +137,7 @@ func resourceZipFileUpdate(d *schema.ResourceData, meta interface{}) error {
 	return nil
 }
 
-func resourceZipFileDelete(d *schema.ResourceData, meta interface{}) error {
+func resourceArchiveFileDelete(d *schema.ResourceData, meta interface{}) error {
 	output_path := d.Get("output_path").(string)
 	fi, err := os.Stat(output_path)
 	if os.IsNotExist(err) {
@@ -151,7 +151,7 @@ func resourceZipFileDelete(d *schema.ResourceData, meta interface{}) error {
 	return nil
 }
 
-func resourceZipFileExists(d *schema.ResourceData, meta interface{}) (bool, error) {
+func resourceArchiveFileExists(d *schema.ResourceData, meta interface{}) (bool, error) {
 	output_path := d.Get("output_path").(string)
 	_, err := os.Stat(output_path)
 	if os.IsNotExist(err) {

builtin/providers/archive/resource_archive_file_test.go

@@ -0,0 +1,92 @@
+package archive
+
+import (
+	"fmt"
+	r "github.com/hashicorp/terraform/helper/resource"
+	"github.com/hashicorp/terraform/terraform"
+	"os"
+	"testing"
+)
+
+func TestAccArchiveFile_Basic(t *testing.T) {
+	var fileSize string
+	r.Test(t, r.TestCase{
+		Providers: testProviders,
+		CheckDestroy: r.ComposeTestCheckFunc(
+			testAccArchiveFileMissing("zip_file_acc_test.zip"),
+		),
+		Steps: []r.TestStep{
+			r.TestStep{
+				Config: testAccArchiveFileContentConfig,
+				Check: r.ComposeTestCheckFunc(
+					testAccArchiveFileExists("zip_file_acc_test.zip", &fileSize),
+					r.TestCheckResourceAttrPtr("archive_file.foo", "output_size", &fileSize),
+				),
+			},
+			r.TestStep{
+				Config: testAccArchiveFileFileConfig,
+				Check: r.ComposeTestCheckFunc(
+					testAccArchiveFileExists("zip_file_acc_test.zip", &fileSize),
+					r.TestCheckResourceAttrPtr("archive_file.foo", "output_size", &fileSize),
+				),
+			},
+			r.TestStep{
+				Config: testAccArchiveFileDirConfig,
+				Check: r.ComposeTestCheckFunc(
+					testAccArchiveFileExists("zip_file_acc_test.zip", &fileSize),
+					r.TestCheckResourceAttrPtr("archive_file.foo", "output_size", &fileSize),
+				),
+			},
+		},
+	})
+}
+
+func testAccArchiveFileExists(filename string, fileSize *string) r.TestCheckFunc {
+	return func(s *terraform.State) error {
+		*fileSize = ""
+		fi, err := os.Stat(filename)
+		if err != nil {
+			return err
+		}
+		*fileSize = fmt.Sprintf("%d", fi.Size())
+		return nil
+	}
+}
+
+func testAccArchiveFileMissing(filename string) r.TestCheckFunc {
+	return func(s *terraform.State) error {
+		_, err := os.Stat(filename)
+		if err != nil {
+			if os.IsNotExist(err) {
+				return nil
+			}
+			return err
+		}
+		return fmt.Errorf("found file expected to be deleted: %s", filename)
+	}
+}
+
+var testAccArchiveFileContentConfig = `
+resource "archive_file" "foo" {
+  type                    = "zip"
+  source_content          = "This is some content"
+  source_content_filename = "content.txt"
+  output_path             = "zip_file_acc_test.zip"
+}
+`
+
+var testAccArchiveFileFileConfig = `
+resource "archive_file" "foo" {
+  type        = "zip"
+  source_file = "test-fixtures/test-file.txt"
+  output_path = "zip_file_acc_test.zip"
+}
+`
+
+var testAccArchiveFileDirConfig = `
+resource "archive_file" "foo" {
+  type        = "zip"
+  source_dir  = "test-fixtures/test-dir"
+  output_path = "zip_file_acc_test.zip"
+}
+`

builtin/providers/archive/test-fixtures/test-dir/file1.txt

@@ -0,0 +1 @@
+This is file 1

builtin/providers/archive/test-fixtures/test-dir/file2.txt

@@ -0,0 +1 @@
+This is file 2

builtin/providers/archive/test-fixtures/test-dir/file3.txt

@@ -0,0 +1 @@
+This is file 3

builtin/providers/archive/test-fixtures/test-file.txt

@@ -0,0 +1 @@
+This is test content

builtin/providers/zip/zip_archiver.go → builtin/providers/archive/zip_archiver.go

@@ -1,4 +1,4 @@
-package zip
+package archive
 
 import (
 	"archive/zip"

builtin/providers/zip/zip_archiver_test.go → builtin/providers/archive/zip_archiver_test.go

@@ -1,21 +1,13 @@
-package zip
+package archive
 
 import (
 	"archive/zip"
 	"io/ioutil"
-	"os"
-	"path/filepath"
 	"testing"
 )
 
 func TestZipArchiver_Content(t *testing.T) {
-	dir, err := createTestDestination()
-	if err != nil {
-		t.Fatalf("could not prepare temporary files: %s", err)
-	}
-	defer dropTestDestination(dir)
-
-	zipfilepath := filepath.Join(dir, "content.zip")
+	zipfilepath := "archive-content.zip"
 	archiver := NewZipArchiver(zipfilepath)
 	if err := archiver.ArchiveContent([]byte("This is some content"), "content.txt"); err != nil {
 		t.Fatalf("unexpected error: %s", err)
@@ -27,18 +19,9 @@ func TestZipArchiver_Content(t *testing.T) {
 }
 
 func TestZipArchiver_File(t *testing.T) {
-	dir, err := createTestDestination()
-	if err != nil {
-		t.Fatalf("could not prepare temporary files: %s", err)
-	}
-	defer dropTestDestination(dir)
-
-	testfilename := filepath.Join(dir, "test-file.txt")
-	ioutil.WriteFile(testfilename, []byte("This is test content"), os.FileMode(0666))
-
-	zipfilepath := filepath.Join(dir, "content.zip")
+	zipfilepath := "archive-file.zip"
 	archiver := NewZipArchiver(zipfilepath)
-	if err := archiver.ArchiveFile(testfilename); err != nil {
+	if err := archiver.ArchiveFile("./test-fixtures/test-file.txt"); err != nil {
 		t.Fatalf("unexpected error: %s", err)
 	}
 
@@ -48,21 +31,9 @@ func TestZipArchiver_File(t *testing.T) {
 }
 
 func TestZipArchiver_Dir(t *testing.T) {
-	dir, err := createTestDestination()
-	if err != nil {
-		t.Fatalf("could not prepare temporary files: %s", err)
-	}
-	defer dropTestDestination(dir)
-
-	testdirpath := filepath.Join(dir, "contents")
-	os.MkdirAll(testdirpath, os.FileMode(0666))
-	ioutil.WriteFile(filepath.Join(testdirpath, "file1.txt"), []byte("This is file 1"), os.FileMode(0666))
-	ioutil.WriteFile(filepath.Join(testdirpath, "file2.txt"), []byte("This is file 2"), os.FileMode(0666))
-	ioutil.WriteFile(filepath.Join(testdirpath, "file3.txt"), []byte("This is file 3"), os.FileMode(0666))
-
-	zipfilepath := filepath.Join(dir, "content.zip")
+	zipfilepath := "archive-dir.zip"
 	archiver := NewZipArchiver(zipfilepath)
-	if err := archiver.ArchiveDir(testdirpath); err != nil {
+	if err := archiver.ArchiveDir("./test-fixtures/test-dir"); err != nil {
 		t.Fatalf("unexpected error: %s", err)
 	}
 
@@ -73,14 +44,6 @@ func TestZipArchiver_Dir(t *testing.T) {
 	})
 }
 
-func createTestDestination() (string, error) {
-	return ioutil.TempDir("./", "zip_archiver_")
-}
-
-func dropTestDestination(dir string) {
-	os.RemoveAll(dir)
-}
-
 func ensureContents(t *testing.T, zipfilepath string, wants map[string][]byte) {
 	r, err := zip.OpenReader(zipfilepath)
 	if err != nil {