no fucking idea

envelop/envelop.go

@@ -95,7 +95,12 @@ func (this *Enveloper) WriteToWriter(w io.Writer) error {
 	defer z.Close()
 	if err := this.WritePayload(z); err != nil {
 		return err
-	} else if err := this.WriteMetadata(z); err != nil {
+	}
+	if err := this.CreateEnvelopCompletely(); err != nil {
+		return err
+	}
+
+	if err := this.WriteMetadata(z); err != nil {
 		return err
 	} else if err := this.WriteEncryptedKey(z); err != nil {
 		return err

envelop/envelop_test.go

@@ -3,38 +3,82 @@ package envelop
 import (
 	"archive/zip"
 	"bytes"
+	"errors"
+	"fmt"
 	"github.com/didiercrunch/ecrypto/helper"
 	"io"
 	"reflect"
 	"testing"
 )
 
-type mockPayload struct{}
+var _ = fmt.Print
+
+type mockPayload struct {
+	MethodsCall []string
+}
+
+func newMockPayload() *mockPayload {
+	return &mockPayload{make([]string, 0)}
+}
+
+func (this *mockPayload) addMethodCall(methodName string) {
+	this.MethodsCall = append(this.MethodsCall, methodName)
+}
+
+//  assert firstToBeCalled is called before secondToBeCalled.  Calls can be made
+//  between them and defore firstToBeCalled and after secondToBeCalled.
+func (this *mockPayload) assertMethodCallOrder(firstToBeCalled, secondToBeCalled string) error {
+	var firstToBeCalledIdx, secondToBeCalledIdx = -1, -1
+	for i, name := range this.MethodsCall {
+		if firstToBeCalledIdx == -1 && name == firstToBeCalled {
+			firstToBeCalledIdx = i
+		}
+		if secondToBeCalledIdx == -1 && name == secondToBeCalled {
+			secondToBeCalledIdx = i
+		}
+	}
+	if firstToBeCalledIdx == -1 {
+		return errors.New(firstToBeCalled + " is never called")
+	}
+	if secondToBeCalledIdx == -1 {
+		return errors.New(secondToBeCalled + " is never called")
+	}
+	if firstToBeCalledIdx >= secondToBeCalledIdx {
+		return errors.New(firstToBeCalled + " is called after " + secondToBeCalled)
+	}
+	return nil
+}
 
 func (this *mockPayload) GetKey() []byte {
+	this.addMethodCall("GetKey")
 	return []byte{1, 2, 3}
 }
 
 func (this *mockPayload) GetHash() []byte {
+	this.addMethodCall("GetHash")
 	return []byte{10, 9, 8}
 }
 
 func (this *mockPayload) GetAlgorithm() string {
+	this.addMethodCall("GetAlgorithm")
 	symetricEncryptionAlgorithm := "DES"
 	return symetricEncryptionAlgorithm
 }
 
 func (this *mockPayload) GetMode() string {
+	this.addMethodCall("GetMode")
 	symetricEncryptionMode := "OFB"
 	return symetricEncryptionMode
 }
 
 func (this *mockPayload) GetHashMethod() string {
+	this.addMethodCall("GetHashMethod")
 	theHashMethodUsedInThePayLoad := "SHA1"
 	return theHashMethodUsedInThePayLoad
 }
 
 func (this *mockPayload) GetPayloadData() io.Reader {
+	this.addMethodCall("GetPayloadData")
 	someData := `some data must be here.  In reality, the data
 	             would be the encrypted payload.  This will be
 				the big chunk of the data.
@@ -67,7 +111,7 @@ func (this *mockSigner) Sign(data []byte) ([]byte, error) {
 func TestEncryptKey(t *testing.T) {
 	env := &Enveloper{
 		encryptor: &mockEncryptor{},
-		payload:   &mockPayload{},
+		payload:   newMockPayload(),
 	}
 	if enc, err := env.EncryptKey(); err != nil {
 		t.Error(err)
@@ -79,7 +123,7 @@ func TestEncryptKey(t *testing.T) {
 func TestCreateEnvelopCompletelyEncryptKey(t *testing.T) {
 	env := &Enveloper{
 		encryptor: &mockEncryptor{},
-		payload:   &mockPayload{},
+		payload:   newMockPayload(),
 		signer:    &mockSigner{},
 	}
 	if err := env.CreateEnvelopCompletely(); err != nil {
@@ -104,7 +148,7 @@ func TestSignPayload(t *testing.T) {
 
 func TestCreateEnvelopCompletelySignHash(t *testing.T) {
 	env := &Enveloper{
-		payload:   &mockPayload{},
+		payload:   newMockPayload(),
 		encryptor: &mockEncryptor{},
 		signer:    &mockSigner{},
 	}
@@ -117,7 +161,7 @@ func TestCreateEnvelopCompletelySignHash(t *testing.T) {
 }
 
 func TestCreateMetadata(t *testing.T) {
-	env := &Enveloper{payload: &mockPayload{}}
+	env := &Enveloper{payload: newMockPayload()}
 	exptectedMetaData := &Metadata{
 		BlockAlgorithm:     "DES",
 		BlockMode:          "OFB",
@@ -133,7 +177,7 @@ func TestCreateMetadata(t *testing.T) {
 func TestCreateEnvelopCompletelyMetadata(t *testing.T) {
 	env := &Enveloper{
 		encryptor: &mockEncryptor{},
-		payload:   &mockPayload{},
+		payload:   newMockPayload(),
 		signer:    &mockSigner{},
 	}
 	if err := env.CreateEnvelopCompletely(); err != nil {
@@ -146,7 +190,9 @@ func TestCreateEnvelopCompletelyMetadata(t *testing.T) {
 
 func TestWriteToWriter(t *testing.T) {
 	env := &Enveloper{
-		payload: &mockPayload{},
+		payload:   newMockPayload(),
+		signer:    &mockSigner{},
+		encryptor: &mockEncryptor{},
 	}
 	w := helper.NewMockIoWriter()
 	if err := env.WriteToWriter(w); err != nil {
@@ -161,3 +207,19 @@ func TestWriteToWriter(t *testing.T) {
 		t.Error("wrong file number")
 	}
 }
+
+func TestMethodOrder(t *testing.T) {
+	mockPayload := newMockPayload()
+	env := &Enveloper{
+		payload:   mockPayload,
+		signer:    &mockSigner{},
+		encryptor: &mockEncryptor{},
+	}
+	w := helper.NewMockIoWriter()
+	if err := env.WriteToWriter(w); err != nil {
+		t.Error(err)
+	}
+	if err := mockPayload.assertMethodCallOrder("GetPayloadData", "GetHashMethod"); err != nil {
+		t.Error(err)
+	}
+}